diff --git a/cmake/modules/FindQuazip.cmake b/cmake/modules/FindQuazip.cmake new file mode 100644 index 0000000000..c079ee6bbb --- /dev/null +++ b/cmake/modules/FindQuazip.cmake @@ -0,0 +1,42 @@ +# Find the static Quazip library +# +# You must provide a QUAZIP_ROOT_DIR which contains lib and include directories +# +# Once done this will define +# +# QUAZIP_FOUND - system found quazip +# QUAZIP_INCLUDE_DIRS - the quazip include directory +# QUAZIP_LIBRARIES - Link this to use quazip +# +# Created on 6/25/2013 by Stephen Birarda +# Copyright (c) 2013 High Fidelity +# + +if (QUAZIP_LIBRARIES AND QUAZIP_INCLUDE_DIRS) + # in cache already + set(QUAZIP_FOUND TRUE) +else (QUAZIP_LIBRARIES AND QUAZIP_INCLUDE_DIRS) + find_path(QUAZIP_INCLUDE_DIRS quazip.h ${QUAZIP_ROOT_DIR}/include) + + if (APPLE) + find_library(QUAZIP_LIBRARIES libquazip.a ${QUAZIP_ROOT_DIR}/lib/MacOS/) + endif () + + if (QUAZIP_INCLUDE_DIRS AND QUAZIP_LIBRARIES) + set(QUAZIP_FOUND TRUE) + endif (QUAZIP_INCLUDE_DIRS AND QUAZIP_LIBRARIES) + + if (QUAZIP_FOUND) + if (NOT QUAZIP_FIND_QUIETLY) + message(STATUS "Found quazip: ${QUAZIP_LIBRARIES}") + endif (NOT QUAZIP_FIND_QUIETLY) + else (QUAZIP_FOUND) + if (QUAZIP_FIND_REQUIRED) + message(FATAL_ERROR "Could not find quazip") + endif (QUAZIP_FIND_REQUIRED) + endif (QUAZIP_FOUND) + + # show the QUAZIP_INCLUDE_DIRS and QUAZIP_LIBRARIES variables only in the advanced view + mark_as_advanced(QUAZIP_INCLUDE_DIRS QUAZIP_LIBRARIES) + +endif (QUAZIP_LIBRARIES AND QUAZIP_INCLUDE_DIRS) \ No newline at end of file diff --git a/hifi.podspec b/hifi.podspec new file mode 100644 index 0000000000..06f65aa322 --- /dev/null +++ b/hifi.podspec @@ -0,0 +1,89 @@ +# +# Be sure to run `pod spec lint hifi.podspec' to ensure this is a +# valid spec and remove all comments before submitting the spec. +# +# To learn more about the attributes see http://docs.cocoapods.org/specification.html +# +Pod::Spec.new do |s| + s.name = "hifi" + s.version = "0.0.1" + s.summary = "Test platform for various render and interface tests for next-gen VR system." + + s.homepage = "https://github.com/worklist/hifi" + + # Specify the license type. CocoaPods detects automatically the license file if it is named + # 'LICENCE*.*' or 'LICENSE*.*', however if the name is different, specify it. + # s.license = 'MIT (example)' + + # Specify the authors of the library, with email addresses. You can often find + # the email addresses of the authors by using the SCM log. E.g. $ git log + # + s.author = { "Worklist" => "contact@worklist.net" } + + # Specify the location from where the source should be retrieved. + # + s.source = { :git => "https://github.com/worklist/hifi.git", :commit => "ddc85272b939922c32e6a80f763e6de3cb00ab1a" } + + s.platform = :ios + s.ios.deployment_target = "6.0" + + # A list of file patterns which select the source files that should be + # added to the Pods project. If the pattern is a directory then the + # path will automatically have '*.{h,m,mm,c,cpp}' appended. + # + # s.source_files = 'Classes', 'Classes/**/*.{h,m}' + # s.exclude_files = 'Classes/Exclude' + + s.subspec "shared" do |sp| + sp.source_files = "libraries/shared/src" + sp.public_header_files = "librares/shared/src" + sp.exclude_files = "libraries/shared/src/UrlReader.*" + end + + s.subspec "audio" do |sp| + sp.source_files = "libraries/audio/src" + sp.public_header_files = "libraries/audio/src" + sp.xcconfig = { 'CLANG_CXX_LIBRARY' => "libc++" } + sp.dependency 'glm' + end + + # A list of file patterns which select the header files that should be + # made available to the application. If the pattern is a directory then the + # path will automatically have '*.h' appended. + # + # If you do not explicitly set the list of public header files, + # all headers of source_files will be made public. + # + # s.public_header_files = 'Classes/**/*.h' + + # A list of paths to preserve after installing the Pod. + # CocoaPods cleans by default any file that is not used. + # Please don't include documentation, example, and test files. + # + # s.preserve_paths = "FilesToSave", "MoreFilesToSave" + + # Specify a list of frameworks that the application needs to link + # against for this Pod to work. + # + # s.framework = 'SomeFramework' + # s.frameworks = 'SomeFramework', 'AnotherFramework' + + # Specify a list of libraries that the application needs to link + # against for this Pod to work. + # + # s.library = 'iconv' + # s.libraries = 'iconv', 'xml2' + + # If this Pod uses ARC, specify it like so. + # + s.requires_arc = false + + # If you need to specify any other build settings, add them to the + # xcconfig hash. + # + # s.xcconfig = { 'CLANG_CXX_LIBRARY' => "libc++" } + + # Finally, specify any Pods that this Pod depends on. + # + # s.dependency 'JSONKit', '~> 1.4' +end diff --git a/interface/CMakeLists.txt b/interface/CMakeLists.txt index 79e924b65d..e7086e22be 100755 --- a/interface/CMakeLists.txt +++ b/interface/CMakeLists.txt @@ -65,10 +65,14 @@ if (APPLE) endif (APPLE) -find_package(Qt4 REQUIRED QtCore QtGui QtNetwork QtOpenGL) +find_package(Qt4 REQUIRED QtCore QtGui QtNetwork QtOpenGL QtWebKit) include(${QT_USE_FILE}) SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -isystem ${QT_QTGUI_INCLUDE_DIR}") +set(QUAZIP_ROOT_DIR ${CMAKE_CURRENT_SOURCE_DIR}/external/quazip) +add_subdirectory(external/fervor/) +include_directories(external/fervor/) + # run qt moc on qt-enabled headers qt4_wrap_cpp(INTERFACE_SRCS src/Application.h src/AvatarVoxelSystem.h src/Webcam.h src/ui/BandwidthDialog.h) @@ -108,7 +112,13 @@ include_directories( ${OPENCV_INCLUDE_DIRS} ) -target_link_libraries(${TARGET_NAME} ${QT_LIBRARIES} ${OPENCV_LIBRARIES} ${ZLIB_LIBRARIES}) +target_link_libraries( + ${TARGET_NAME} + ${QT_LIBRARIES} + ${OPENCV_LIBRARIES} + ${ZLIB_LIBRARIES} + fervor +) if (APPLE) # link in required OS X frameworks and include the right GL headers diff --git a/interface/external/fervor/CMakeLists.txt b/interface/external/fervor/CMakeLists.txt new file mode 100644 index 0000000000..9afeb6f4ec --- /dev/null +++ b/interface/external/fervor/CMakeLists.txt @@ -0,0 +1,23 @@ +cmake_minimum_required(VERSION 2.8) +project(Fervor) +find_package(Qt4 REQUIRED) + +add_definitions(-DFV_GUI) + +file(GLOB FERVOR_SOURCES *.cpp) +file(GLOB FERVOR_HEADERS *.h) +file(GLOB FERVOR_UI *.ui) + +qt4_wrap_ui(FERVOR_WRAPPED_UI ${FERVOR_UI}) +qt4_wrap_cpp(FERVOR_MOC_SOURCES ${FERVOR_HEADERS}) + +set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/../cmake/modules/") +find_package(Quazip REQUIRED) + +include_directories( + ${CMAKE_CURRENT_BINARY_DIR} + ${QUAZIP_INCLUDE_DIRS} +) + +add_library(fervor ${FERVOR_SOURCES} ${FERVOR_HEADERS} ${FERVOR_MOC_SOURCES} ${FERVOR_WRAPPED_UI}) +target_link_libraries(fervor ${QUAZIP_LIBRARIES}) \ No newline at end of file diff --git a/interface/external/fervor/fvavailableupdate.cpp b/interface/external/fervor/fvavailableupdate.cpp new file mode 100755 index 0000000000..f0f6cb91cd --- /dev/null +++ b/interface/external/fervor/fvavailableupdate.cpp @@ -0,0 +1,97 @@ +#include "fvavailableupdate.h" + +FvAvailableUpdate::FvAvailableUpdate(QObject *parent) : + QObject(parent) +{ + // noop +} + +QString FvAvailableUpdate::GetTitle() +{ + return m_title; +} + +void FvAvailableUpdate::SetTitle(QString title) +{ + m_title = title; +} + +QUrl FvAvailableUpdate::GetReleaseNotesLink() +{ + return m_releaseNotesLink; +} + +void FvAvailableUpdate::SetReleaseNotesLink(QUrl releaseNotesLink) +{ + m_releaseNotesLink = releaseNotesLink; +} + +void FvAvailableUpdate::SetReleaseNotesLink(QString releaseNotesLink) +{ + SetReleaseNotesLink(QUrl(releaseNotesLink)); +} + +QString FvAvailableUpdate::GetPubDate() +{ + return m_pubDate; +} + +void FvAvailableUpdate::SetPubDate(QString pubDate) +{ + m_pubDate = pubDate; +} + +QUrl FvAvailableUpdate::GetEnclosureUrl() +{ + return m_enclosureUrl; +} + +void FvAvailableUpdate::SetEnclosureUrl(QUrl enclosureUrl) +{ + m_enclosureUrl = enclosureUrl; +} + +void FvAvailableUpdate::SetEnclosureUrl(QString enclosureUrl) +{ + SetEnclosureUrl(QUrl(enclosureUrl)); +} + +QString FvAvailableUpdate::GetEnclosureVersion() +{ + return m_enclosureVersion; +} + +void FvAvailableUpdate::SetEnclosureVersion(QString enclosureVersion) +{ + m_enclosureVersion = enclosureVersion; +} + +QString FvAvailableUpdate::GetEnclosurePlatform() +{ + return m_enclosurePlatform; +} + +void FvAvailableUpdate::SetEnclosurePlatform(QString enclosurePlatform) +{ + m_enclosurePlatform = enclosurePlatform; +} + +unsigned long FvAvailableUpdate::GetEnclosureLength() +{ + return m_enclosureLength; +} + +void FvAvailableUpdate::SetEnclosureLength(unsigned long enclosureLength) +{ + m_enclosureLength = enclosureLength; +} + +QString FvAvailableUpdate::GetEnclosureType() +{ + return m_enclosureType; +} + +void FvAvailableUpdate::SetEnclosureType(QString enclosureType) +{ + m_enclosureType = enclosureType; +} diff --git a/interface/external/fervor/fvavailableupdate.h b/interface/external/fervor/fvavailableupdate.h new file mode 100755 index 0000000000..6bf3cf9c97 --- /dev/null +++ b/interface/external/fervor/fvavailableupdate.h @@ -0,0 +1,51 @@ +#ifndef FVAVAILABLEUPDATE_H +#define FVAVAILABLEUPDATE_H + +#include +#include + +class FvAvailableUpdate : public QObject +{ + Q_OBJECT +public: + explicit FvAvailableUpdate(QObject *parent = 0); + + QString GetTitle(); + void SetTitle(QString title); + + QUrl GetReleaseNotesLink(); + void SetReleaseNotesLink(QUrl releaseNotesLink); + void SetReleaseNotesLink(QString releaseNotesLink); + + QString GetPubDate(); + void SetPubDate(QString pubDate); + + QUrl GetEnclosureUrl(); + void SetEnclosureUrl(QUrl enclosureUrl); + void SetEnclosureUrl(QString enclosureUrl); + + QString GetEnclosureVersion(); + void SetEnclosureVersion(QString enclosureVersion); + + QString GetEnclosurePlatform(); + void SetEnclosurePlatform(QString enclosurePlatform); + + unsigned long GetEnclosureLength(); + void SetEnclosureLength(unsigned long enclosureLength); + + QString GetEnclosureType(); + void SetEnclosureType(QString enclosureType); + +private: + QString m_title; + QUrl m_releaseNotesLink; + QString m_pubDate; + QUrl m_enclosureUrl; + QString m_enclosureVersion; + QString m_enclosurePlatform; + unsigned long m_enclosureLength; + QString m_enclosureType; + +}; + +#endif // FVAVAILABLEUPDATE_H diff --git a/interface/external/fervor/fvignoredversions.cpp b/interface/external/fervor/fvignoredversions.cpp new file mode 100755 index 0000000000..c665f9cff7 --- /dev/null +++ b/interface/external/fervor/fvignoredversions.cpp @@ -0,0 +1,74 @@ +#include "fvignoredversions.h" +#include "fvversioncomparator.h" +#include +#include +#include + +// QSettings key for the latest skipped version +#define FV_IGNORED_VERSIONS_LATEST_SKIPPED_VERSION_KEY "FVLatestSkippedVersion" + + +FVIgnoredVersions::FVIgnoredVersions(QObject *parent) : +QObject(parent) +{ + // noop +} + +bool FVIgnoredVersions::VersionIsIgnored(QString version) +{ + // We assume that variable 'version' contains either: + // 1) The current version of the application (ignore) + // 2) The version that was skipped before and thus stored in QSettings (ignore) + // 3) A newer version (don't ignore) + // 'version' is not likely to contain an older version in any case. + + if (version == QCoreApplication::applicationVersion()) { + return true; + } + + QSettings settings(QSettings::NativeFormat, + QSettings::UserScope, + QCoreApplication::organizationDomain(), + QCoreApplication::applicationName()); + + //QSettings settings; + if (settings.contains(FV_IGNORED_VERSIONS_LATEST_SKIPPED_VERSION_KEY)) { + QString lastSkippedVersion = settings.value(FV_IGNORED_VERSIONS_LATEST_SKIPPED_VERSION_KEY).toString(); + if (version == lastSkippedVersion) { + // Implicitly skipped version - skip + return true; + } + } + + std::string currentAppVersion = QCoreApplication::applicationVersion().toStdString(); + std::string suggestedVersion = std::string(version.toStdString()); + if (FvVersionComparator::CompareVersions(currentAppVersion, suggestedVersion) == FvVersionComparator::kAscending) { + // Newer version - do not skip + return false; + } + + // Fallback - skip + return true; +} + +void FVIgnoredVersions::IgnoreVersion(QString version) +{ + if (version == QCoreApplication::applicationVersion()) { + // Don't ignore the current version + return; + } + + if (version.isEmpty()) { + return; + } + + QSettings settings(QSettings::NativeFormat, + QSettings::UserScope, + QCoreApplication::organizationDomain(), + QCoreApplication::applicationName()); + + + settings.setValue(FV_IGNORED_VERSIONS_LATEST_SKIPPED_VERSION_KEY, version); + + return; +} \ No newline at end of file diff --git a/interface/external/fervor/fvignoredversions.h b/interface/external/fervor/fvignoredversions.h new file mode 100755 index 0000000000..4e85f1b565 --- /dev/null +++ b/interface/external/fervor/fvignoredversions.h @@ -0,0 +1,19 @@ +#ifndef FVIGNOREDVERSIONS_H +#define FVIGNOREDVERSIONS_H + +#include + +class FVIgnoredVersions : public QObject +{ + Q_OBJECT + +public: + static bool VersionIsIgnored(QString version); + static void IgnoreVersion(QString version); + +private: + explicit FVIgnoredVersions(QObject *parent = 0); + +}; + +#endif // FVIGNOREDVERSIONS_H diff --git a/interface/external/fervor/fvplatform.cpp b/interface/external/fervor/fvplatform.cpp new file mode 100755 index 0000000000..1a90ab1dca --- /dev/null +++ b/interface/external/fervor/fvplatform.cpp @@ -0,0 +1,210 @@ +#include "fvplatform.h" +#include +#include + +FvPlatform::FvPlatform(QObject *parent) : + QObject(parent) +{ + // noop +} + +bool FvPlatform::CurrentlyRunningOnPlatform(QString platform) +{ + platform = platform.toUpper().trimmed(); + if (platform.isEmpty()) { + return false; + } + + // Defined on AIX. +#ifdef Q_OS_AIX + if (platform == "Q_OS_AIX") { + return true; + } +#endif + + // Q_OS_BSD4 ("Defined on Any BSD 4.4 system") intentionally skipped. + + // Defined on BSD/OS. +#ifdef Q_OS_BSDI + if (platform == "Q_OS_BSDI") { + return true; + } +#endif + + // Defined on Cygwin. +#ifdef Q_OS_CYGWIN + if (platform == "Q_OS_CYGWIN") { + return true; + } +#endif + + // Q_OS_DARWIN ("Defined on Darwin OS (synonym for Q_OS_MAC)") intentionally skipped. + + // Defined on DG/UX. +#ifdef Q_OS_DGUX + if (platform == "Q_OS_DGUX") { + return true; + } +#endif + + // Defined on DYNIX/ptx. +#ifdef Q_OS_DYNIX + if (platform == "Q_OS_DYNIX") { + return true; + } +#endif + + // Defined on FreeBSD. +#ifdef Q_OS_FREEBSD + if (platform == "Q_OS_FREEBSD") { + return true; + } +#endif + + // Defined on HP-UX. +#ifdef Q_OS_HPUX + if (platform == "Q_OS_HPUX") { + return true; + } +#endif + + // Defined on GNU Hurd. +#ifdef Q_OS_HURD + if (platform == "Q_OS_HURD") { + return true; + } +#endif + + // Defined on SGI Irix. +#ifdef Q_OS_IRIX + if (platform == "Q_OS_IRIX") { + return true; + } +#endif + + // Defined on Linux. +#ifdef Q_OS_LINUX + if (platform == "Q_OS_LINUX") { + return true; + } +#endif + + // Defined on LynxOS. +#ifdef Q_OS_LYNX + if (platform == "Q_OS_LYNX") { + return true; + } +#endif + + // Defined on MAC OS (synonym for Darwin). +#ifdef Q_OS_MAC + if (platform == "Q_OS_MAC") { + return true; + } +#endif + + // Q_OS_MSDOS ("Defined on MS-DOS and Windows") intentionally skipped. + + // Defined on NetBSD. +#ifdef Q_OS_NETBSD + if (platform == "Q_OS_NETBSD") { + return true; + } +#endif + + // Defined on OS/2. +#ifdef Q_OS_OS2 + if (platform == "Q_OS_OS2") { + return true; + } +#endif + + // Defined on OpenBSD. +#ifdef Q_OS_OPENBSD + if (platform == "Q_OS_OPENBSD") { + return true; + } +#endif + + // Defined on XFree86 on OS/2 (not PM). +#ifdef Q_OS_OS2EMX + if (platform == "Q_OS_OS2EMX") { + return true; + } +#endif + + // Defined on HP Tru64 UNIX. +#ifdef Q_OS_OSF + if (platform == "Q_OS_OSF") { + return true; + } +#endif + + // Defined on QNX Neutrino. +#ifdef Q_OS_QNX + if (platform == "Q_OS_QNX") { + return true; + } +#endif + + // Defined on Reliant UNIX. +#ifdef Q_OS_RELIANT + if (platform == "Q_OS_RELIANT") { + return true; + } +#endif + + // Defined on SCO OpenServer 5. +#ifdef Q_OS_SCO + if (platform == "Q_OS_SCO") { + return true; + } +#endif + + // Defined on Sun Solaris. +#ifdef Q_OS_SOLARIS + if (platform == "Q_OS_SOLARIS") { + return true; + } +#endif + + // Defined on Symbian. +#ifdef Q_OS_SYMBIAN + if (platform == "Q_OS_SYMBIAN") { + return true; + } +#endif + + // Defined on DEC Ultrix. +#ifdef Q_OS_ULTRIX + if (platform == "Q_OS_ULTRIX") { + return true; + } +#endif + + // Q_OS_UNIX ("Defined on Any UNIX BSD/SYSV system") intentionally skipped. + + // Defined on UnixWare 7, Open UNIX 8. +#ifdef Q_OS_UNIXWARE + if (platform == "Q_OS_UNIXWARE") { + return true; + } +#endif + + // Defined on Windows CE (note: goes before Q_OS_WIN32) +#ifdef Q_OS_WINCE + if (platform == "Q_OS_WINCE") { + return true; + } +#endif + + // Defined on all supported versions of Windows. +#ifdef Q_OS_WIN32 + if (platform == "Q_OS_WIN32") { + return true; + } +#endif + + // Fallback + return false; +} diff --git a/interface/external/fervor/fvplatform.h b/interface/external/fervor/fvplatform.h new file mode 100755 index 0000000000..a527518097 --- /dev/null +++ b/interface/external/fervor/fvplatform.h @@ -0,0 +1,18 @@ +#ifndef FVPLATFORM_H +#define FVPLATFORM_H + +#include + +class FvPlatform : public QObject +{ + Q_OBJECT + +public: + static bool CurrentlyRunningOnPlatform(QString platform); + +private: + explicit FvPlatform(QObject *parent = 0); + +}; + +#endif // FVPLATFORM_H diff --git a/interface/external/fervor/fvupdatedownloadprogress.cpp b/interface/external/fervor/fvupdatedownloadprogress.cpp new file mode 100755 index 0000000000..0b6e7934ad --- /dev/null +++ b/interface/external/fervor/fvupdatedownloadprogress.cpp @@ -0,0 +1,26 @@ +#include "fvupdatedownloadprogress.h" + +FvUpdateDownloadProgress::FvUpdateDownloadProgress(QWidget *parent) + : QWidget(parent, Qt::SplashScreen) +{ + ui.setupUi(this); + + ui.progress->setValue(0); + +} + +FvUpdateDownloadProgress::~FvUpdateDownloadProgress() +{ + +} + +void FvUpdateDownloadProgress::downloadProgress ( qint64 bytesReceived, qint64 bytesTotal ) +{ + ui.progress->setValue( ((float)bytesReceived / (float)bytesTotal) * 100 ); +} + +void FvUpdateDownloadProgress::close() +{ + this->deleteLater(); + QWidget::close(); +} \ No newline at end of file diff --git a/interface/external/fervor/fvupdatedownloadprogress.h b/interface/external/fervor/fvupdatedownloadprogress.h new file mode 100755 index 0000000000..1b6ab0d709 --- /dev/null +++ b/interface/external/fervor/fvupdatedownloadprogress.h @@ -0,0 +1,23 @@ +#ifndef FVUPDATEDOWNLOADPROGRESS_H +#define FVUPDATEDOWNLOADPROGRESS_H + +#include +#include "ui_fvupdatedownloadprogress.h" + +class FvUpdateDownloadProgress : public QWidget +{ + Q_OBJECT + +public: + FvUpdateDownloadProgress(QWidget *parent = 0); + ~FvUpdateDownloadProgress(); + +public slots: + void downloadProgress ( qint64 bytesReceived, qint64 bytesTotal ); + void close(); + +private: + Ui::FvUpdateDownloadProgress ui; +}; + +#endif // FVUPDATEDOWNLOADPROGRESS_H diff --git a/interface/external/fervor/fvupdatedownloadprogress.ui b/interface/external/fervor/fvupdatedownloadprogress.ui new file mode 100755 index 0000000000..264e8c9728 --- /dev/null +++ b/interface/external/fervor/fvupdatedownloadprogress.ui @@ -0,0 +1,94 @@ + + + FvUpdateDownloadProgress + + + Qt::ApplicationModal + + + + 0 + 0 + 558 + 70 + + + + + 0 + 0 + + + + FvUpdateDownloadProgress + + + + 0 + + + 0 + + + + + QFrame::WinPanel + + + QFrame::Raised + + + + 8 + + + + + + 12 + + + + Qt::LeftToRight + + + QFrame::NoFrame + + + QFrame::Plain + + + Downloading Update... + + + Qt::AlignCenter + + + + + + + + 8 + + + + 24 + + + false + + + false + + + + + + + + + + + + diff --git a/interface/external/fervor/fvupdater.cpp b/interface/external/fervor/fvupdater.cpp new file mode 100755 index 0000000000..66bdc29163 --- /dev/null +++ b/interface/external/fervor/fvupdater.cpp @@ -0,0 +1,908 @@ +#include "fvupdater.h" +#include "fvplatform.h" +#include "fvignoredversions.h" +#include "fvavailableupdate.h" +#include +#include +#include +#include +#include "quazip.h" +#include "quazipfile.h" + +#ifdef Q_WS_MAC +#include "CoreFoundation/CoreFoundation.h" +#endif + +#ifdef FV_GUI +#include "fvupdatewindow.h" +#include "fvupdatedownloadprogress.h" +#include +#include +#else +// QSettings key for automatic update installation +#define FV_NEW_VERSION_POLICY_KEY "FVNewVersionPolicy" +#endif + +#ifdef FV_DEBUG + // Unit tests +# include "fvversioncomparatortest.h" +#endif + +extern QSettings* settings; + +FvUpdater* FvUpdater::m_Instance = 0; + + +FvUpdater* FvUpdater::sharedUpdater() +{ + static QMutex mutex; + if (! m_Instance) { + mutex.lock(); + + if (! m_Instance) { + m_Instance = new FvUpdater; + } + + mutex.unlock(); + } + + return m_Instance; +} + +void FvUpdater::drop() +{ + static QMutex mutex; + mutex.lock(); + delete m_Instance; + m_Instance = 0; + mutex.unlock(); +} + +FvUpdater::FvUpdater() : QObject(0) +{ + m_reply = 0; +#ifdef FV_GUI + m_updaterWindow = 0; +#endif + m_proposedUpdate = 0; + m_requiredSslFingerprint = ""; + htAuthUsername = ""; + htAuthPassword = ""; + skipVersionAllowed = true; + remindLaterAllowed = true; + + connect(&m_qnam, SIGNAL(authenticationRequired(QNetworkReply*, QAuthenticator*)),this, SLOT(authenticationRequired(QNetworkReply*, QAuthenticator*))); + + // Translation mechanism + installTranslator(); + +#ifdef FV_DEBUG + // Unit tests + FvVersionComparatorTest* test = new FvVersionComparatorTest(); + test->runAll(); + delete test; +#endif + +} + +FvUpdater::~FvUpdater() +{ + if (m_proposedUpdate) { + delete m_proposedUpdate; + m_proposedUpdate = 0; + } + +#ifdef FV_GUI + hideUpdaterWindow(); +#endif +} + +void FvUpdater::installTranslator() +{ + QTranslator translator; + QString locale = QLocale::system().name(); + translator.load(QString("fervor_") + locale); + +#if QT_VERSION < 0x050000 + QTextCodec::setCodecForTr(QTextCodec::codecForName("utf8")); +#endif + + qApp->installTranslator(&translator); +} + +#ifdef FV_GUI +void FvUpdater::showUpdaterWindowUpdatedWithCurrentUpdateProposal() +{ + // Destroy window if already exists + hideUpdaterWindow(); + + // Create a new window + m_updaterWindow = new FvUpdateWindow(NULL, skipVersionAllowed, remindLaterAllowed); + m_updaterWindow->UpdateWindowWithCurrentProposedUpdate(); + m_updaterWindow->show(); +} + +void FvUpdater::hideUpdaterWindow() +{ + if (m_updaterWindow) { + if (! m_updaterWindow->close()) { + qWarning() << "Update window didn't close, leaking memory from now on"; + } + + // not deleting because of Qt::WA_DeleteOnClose + + m_updaterWindow = 0; + } +} + +void FvUpdater::updaterWindowWasClosed() +{ + // (Re-)nullify a pointer to a destroyed QWidget or you're going to have a bad time. + m_updaterWindow = 0; +} +#endif + +void FvUpdater::SetFeedURL(QUrl feedURL) +{ + m_feedURL = feedURL; +} + +void FvUpdater::SetFeedURL(QString feedURL) +{ + SetFeedURL(QUrl(feedURL)); +} + +QString FvUpdater::GetFeedURL() +{ + return m_feedURL.toString(); +} + +FvAvailableUpdate* FvUpdater::GetProposedUpdate() +{ + return m_proposedUpdate; +} + + +void FvUpdater::InstallUpdate() +{ + if(m_proposedUpdate==NULL) + { + qWarning() << "Abort Update: No update prososed! This should not happen."; + return; + } + + // Prepare download + QUrl url = m_proposedUpdate->GetEnclosureUrl(); + + // Check SSL Fingerprint if required + if(url.scheme()=="https" && !m_requiredSslFingerprint.isEmpty()) + if( !checkSslFingerPrint(url) ) // check failed + { + qWarning() << "Update aborted."; + return; + } + + // Start Download + QNetworkReply* reply = m_qnam.get(QNetworkRequest(url)); + connect(reply, SIGNAL(finished()), this, SLOT(httpUpdateDownloadFinished())); + + // Maybe Check request 's return value + if (reply->error() != QNetworkReply::NoError) + { + qDebug()<<"Unable to download the update: "<errorString(); + return; + } + else + qDebug()<<"OK"; + + // Show download Window +#ifdef FV_GUI + FvUpdateDownloadProgress* dlwindow = new FvUpdateDownloadProgress(NULL); + connect(reply, SIGNAL(downloadProgress(qint64, qint64)), dlwindow, SLOT(downloadProgress(qint64, qint64) )); + connect(&m_qnam, SIGNAL(finished(QNetworkReply*)), dlwindow, SLOT(close())); + dlwindow->show(); +#endif + + emit (updatedFinishedSuccessfully()); + +#ifdef FV_GUI + hideUpdaterWindow(); +#endif +} + +void FvUpdater::httpUpdateDownloadFinished() +{ + QNetworkReply* reply = qobject_cast(sender()); + if(reply==NULL) + { + qWarning()<<"The slot httpUpdateDownloadFinished() should only be invoked by S&S."; + return; + } + + if(reply->error() == QNetworkReply::NoError) + { + int httpstatuscode = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toUInt(); + + // no error received? + if (reply->error() == QNetworkReply::NoError) + { + if (reply->isReadable()) + { +#ifdef Q_WS_MAC + CFURLRef appURLRef = CFBundleCopyBundleURL(CFBundleGetMainBundle()); + char path[PATH_MAX]; + if (!CFURLGetFileSystemRepresentation(appURLRef, TRUE, (UInt8 *)path, PATH_MAX)) { + // error! + } + + CFRelease(appURLRef); + QString filePath = QString(path); + QString rootDirectory = filePath.left(filePath.lastIndexOf("/")); +#else + QString rootDirectory = QCoreApplication::applicationDirPath() + "/"; +#endif + + // Write download into File + QFileInfo fileInfo=reply->url().path(); + QString fileName = rootDirectory + fileInfo.fileName(); + //qDebug()<<"Writing downloaded file into "<readAll()); + file.close(); + + // Retrieve List of updated files (Placed in an extra scope to avoid QuaZIP handles the archive permanently and thus avoids the deletion.) + { + QuaZip zip(fileName); + if (!zip.open(QuaZip::mdUnzip)) { + qWarning("testRead(): zip.open(): %d", zip.getZipError()); + return; + } + zip.setFileNameCodec("IBM866"); + QList updateFiles = zip.getFileInfoList(); + + // Rename all current files with available update. + for (int i=0;ideleteLater(); + } // If !reply->error END +} // httpUpdateDownloadFinished END + +bool FvUpdater::unzipUpdate(const QString & filePath, const QString & extDirPath, const QString & singleFileName ) +{ + QuaZip zip(filePath); + + if (!zip.open(QuaZip::mdUnzip)) { + qWarning()<GetEnclosureVersion()); + +#ifdef FV_GUI + hideUpdaterWindow(); +#endif +} + +void FvUpdater::RemindMeLater() +{ + //qDebug() << "Remind me later"; + +#ifdef FV_GUI + hideUpdaterWindow(); +#endif +} + +bool FvUpdater::CheckForUpdates(bool silentAsMuchAsItCouldGet) +{ + if (m_feedURL.isEmpty()) { + qCritical() << "Please set feed URL via setFeedURL() before calling CheckForUpdates()."; + return false; + } + + m_silentAsMuchAsItCouldGet = silentAsMuchAsItCouldGet; + + // Check if application's organization name and domain are set, fail otherwise + // (nowhere to store QSettings to) + if (QCoreApplication::organizationName().isEmpty()) { + qCritical() << "QCoreApplication::organizationName is not set. Please do that."; + return false; + } + if (QCoreApplication::organizationDomain().isEmpty()) { + qCritical() << "QCoreApplication::organizationDomain is not set. Please do that."; + return false; + } + + if(QCoreApplication::applicationName().isEmpty()) { + qCritical() << "QCoreApplication::applicationName is not set. Please do that."; + return false; + } + + // Set application version is not set yet + if (QCoreApplication::applicationVersion().isEmpty()) { + qCritical() << "QCoreApplication::applicationVersion is not set. Please do that."; + return false; + } + + cancelDownloadFeed(); + m_httpRequestAborted = false; + startDownloadFeed(m_feedURL); + + return true; +} + +bool FvUpdater::CheckForUpdatesSilent() +{ + return CheckForUpdates(true); +} + +bool FvUpdater::CheckForUpdatesNotSilent() +{ + return CheckForUpdates(false); +} + + +void FvUpdater::startDownloadFeed(QUrl url) +{ + m_xml.clear(); + + // Check SSL Fingerprint if required + if(url.scheme()=="https" && !m_requiredSslFingerprint.isEmpty()) + if( !checkSslFingerPrint(url) ) // check failed + { + qWarning() << "Update aborted."; + return; + } + + + m_reply = m_qnam.get(QNetworkRequest(url)); + + connect(m_reply, SIGNAL(readyRead()), this, SLOT(httpFeedReadyRead())); + connect(m_reply, SIGNAL(downloadProgress(qint64, qint64)), this, SLOT(httpFeedUpdateDataReadProgress(qint64, qint64))); + connect(m_reply, SIGNAL(finished()), this, SLOT(httpFeedDownloadFinished())); +} + +void FvUpdater::cancelDownloadFeed() +{ + if (m_reply) { + m_httpRequestAborted = true; + m_reply->abort(); + } +} + +void FvUpdater::httpFeedReadyRead() +{ + // this slot gets called every time the QNetworkReply has new data. + // We read all of its new data and write it into the file. + // That way we use less RAM than when reading it at the finished() + // signal of the QNetworkReply + m_xml.addData(m_reply->readAll()); +} + +void FvUpdater::httpFeedUpdateDataReadProgress(qint64 bytesRead, + qint64 totalBytes) +{ + Q_UNUSED(bytesRead); + Q_UNUSED(totalBytes); + + if (m_httpRequestAborted) { + return; + } +} + +void FvUpdater::httpFeedDownloadFinished() +{ + if (m_httpRequestAborted) { + m_reply->deleteLater(); + return; + } + + QVariant redirectionTarget = m_reply->attribute(QNetworkRequest::RedirectionTargetAttribute); + if (m_reply->error()) { + + // Error. + showErrorDialog(tr("Feed download failed: %1.").arg(m_reply->errorString()), false); + + } else if (! redirectionTarget.isNull()) { + QUrl newUrl = m_feedURL.resolved(redirectionTarget.toUrl()); + + m_feedURL = newUrl; + m_reply->deleteLater(); + + startDownloadFeed(m_feedURL); + return; + + } else { + + // Done. + xmlParseFeed(); + + } + + m_reply->deleteLater(); + m_reply = 0; +} + +bool FvUpdater::xmlParseFeed() +{ + QString currentTag, currentQualifiedTag; + + QString xmlTitle, xmlLink, xmlReleaseNotesLink, xmlPubDate, xmlEnclosureUrl, + xmlEnclosureVersion, xmlEnclosurePlatform, xmlEnclosureType; + unsigned long xmlEnclosureLength; + + // Parse + while (! m_xml.atEnd()) { + + m_xml.readNext(); + + if (m_xml.isStartElement()) { + + currentTag = m_xml.name().toString(); + currentQualifiedTag = m_xml.qualifiedName().toString(); + + if (m_xml.name() == "item") { + + xmlTitle.clear(); + xmlLink.clear(); + xmlReleaseNotesLink.clear(); + xmlPubDate.clear(); + xmlEnclosureUrl.clear(); + xmlEnclosureVersion.clear(); + xmlEnclosurePlatform.clear(); + xmlEnclosureLength = 0; + xmlEnclosureType.clear(); + + } else if (m_xml.name() == "enclosure") { + + QXmlStreamAttributes attribs = m_xml.attributes(); + + if (attribs.hasAttribute("fervor:platform")) + { + xmlEnclosurePlatform = attribs.value("fervor:platform").toString().trimmed(); + + if (FvPlatform::CurrentlyRunningOnPlatform(xmlEnclosurePlatform)) + { + xmlEnclosureUrl = attribs.hasAttribute("url") ? attribs.value("url").toString().trimmed() : ""; + + xmlEnclosureVersion = ""; + if (attribs.hasAttribute("fervor:version")) + xmlEnclosureVersion = attribs.value("fervor:version").toString().trimmed(); + if (attribs.hasAttribute("sparkle:version")) + xmlEnclosureVersion = attribs.value("sparkle:version").toString().trimmed(); + + xmlEnclosureLength = attribs.hasAttribute("length") ? attribs.value("length").toString().toLong() : 0; + + xmlEnclosureType = attribs.hasAttribute("type") ? attribs.value("type").toString().trimmed() : ""; + } + + } // if hasAttribute flevor:platform END + + } // IF encosure END + + } else if (m_xml.isEndElement()) { + + if (m_xml.name() == "item") { + + // That's it - we have analyzed a single and we'll stop + // here (because the topmost is the most recent one, and thus + // the newest version. + + return searchDownloadedFeedForUpdates(xmlTitle, + xmlLink, + xmlReleaseNotesLink, + xmlPubDate, + xmlEnclosureUrl, + xmlEnclosureVersion, + xmlEnclosurePlatform, + xmlEnclosureLength, + xmlEnclosureType); + + } + + } else if (m_xml.isCharacters() && ! m_xml.isWhitespace()) { + + if (currentTag == "title") { + xmlTitle += m_xml.text().toString().trimmed(); + + } else if (currentTag == "link") { + xmlLink += m_xml.text().toString().trimmed(); + + } else if (currentQualifiedTag == "sparkle:releaseNotesLink") { + xmlReleaseNotesLink += m_xml.text().toString().trimmed(); + + } else if (currentTag == "pubDate") { + xmlPubDate += m_xml.text().toString().trimmed(); + + } + + } + + if (m_xml.error() && m_xml.error() != QXmlStreamReader::PrematureEndOfDocumentError) { + + showErrorDialog(tr("Feed parsing failed: %1 %2.").arg(QString::number(m_xml.lineNumber()), m_xml.errorString()), false); + return false; + + } + } + + return false; +} + + +bool FvUpdater::searchDownloadedFeedForUpdates(QString xmlTitle, + QString xmlLink, + QString xmlReleaseNotesLink, + QString xmlPubDate, + QString xmlEnclosureUrl, + QString xmlEnclosureVersion, + QString xmlEnclosurePlatform, + unsigned long xmlEnclosureLength, + QString xmlEnclosureType) +{ + Q_UNUSED(xmlTitle); + Q_UNUSED(xmlPubDate); + Q_UNUSED(xmlEnclosureLength); + Q_UNUSED(xmlEnclosureType); + + // Validate + if (xmlReleaseNotesLink.isEmpty()) { + if (xmlLink.isEmpty()) { + showErrorDialog(tr("Feed error: \"release notes\" link is empty"), false); + return false; + } else { + xmlReleaseNotesLink = xmlLink; + } + } else { + xmlLink = xmlReleaseNotesLink; + } + if (! (xmlLink.startsWith("http://") || xmlLink.startsWith("https://"))) { + showErrorDialog(tr("Feed error: invalid \"release notes\" link"), false); + return false; + } + if (xmlEnclosureUrl.isEmpty() || xmlEnclosureVersion.isEmpty() || xmlEnclosurePlatform.isEmpty()) { + showErrorDialog(tr("Feed error: invalid \"enclosure\" with the download link"), false); + return false; + } + + // Relevant version? + if (FVIgnoredVersions::VersionIsIgnored(xmlEnclosureVersion)) { + qDebug() << "Version '" << xmlEnclosureVersion << "' is ignored, too old or something like that."; + + showInformationDialog(tr("No updates were found."), false); + + return true; // Things have succeeded when you think of it. + } + + + // + // Success! At this point, we have found an update that can be proposed + // to the user. + // + + if (m_proposedUpdate) { + delete m_proposedUpdate; m_proposedUpdate = 0; + } + m_proposedUpdate = new FvAvailableUpdate(); + m_proposedUpdate->SetTitle(xmlTitle); + m_proposedUpdate->SetReleaseNotesLink(xmlReleaseNotesLink); + m_proposedUpdate->SetPubDate(xmlPubDate); + m_proposedUpdate->SetEnclosureUrl(xmlEnclosureUrl); + m_proposedUpdate->SetEnclosureVersion(xmlEnclosureVersion); + m_proposedUpdate->SetEnclosurePlatform(xmlEnclosurePlatform); + m_proposedUpdate->SetEnclosureLength(xmlEnclosureLength); + m_proposedUpdate->SetEnclosureType(xmlEnclosureType); + +#ifdef FV_GUI + // Show "look, there's an update" window + showUpdaterWindowUpdatedWithCurrentUpdateProposal(); +#else + // Decide ourselves what to do + decideWhatToDoWithCurrentUpdateProposal(); +#endif + + return true; +} + + +void FvUpdater::showErrorDialog(QString message, bool showEvenInSilentMode) +{ + if (m_silentAsMuchAsItCouldGet) { + if (! showEvenInSilentMode) { + // Don't show errors in the silent mode + return; + } + } + +#ifdef FV_GUI + QMessageBox dlFailedMsgBox; + dlFailedMsgBox.setIcon(QMessageBox::Critical); + dlFailedMsgBox.setText(tr("Error")); + dlFailedMsgBox.setInformativeText(message); + dlFailedMsgBox.exec(); +#else + qCritical() << message; +#endif +} + +void FvUpdater::showInformationDialog(QString message, bool showEvenInSilentMode) +{ + if (m_silentAsMuchAsItCouldGet) { + if (! showEvenInSilentMode) { + // Don't show information dialogs in the silent mode + return; + } + } + +#ifdef FV_GUI + QMessageBox dlInformationMsgBox; + dlInformationMsgBox.setIcon(QMessageBox::Information); + dlInformationMsgBox.setText(tr("Information")); + dlInformationMsgBox.setInformativeText(message); + dlInformationMsgBox.exec(); +#else + qDebug() << message; +#endif +} + +void FvUpdater::finishUpdate(QString pathToFinish) +{ + pathToFinish = pathToFinish.isEmpty() ? QCoreApplication::applicationDirPath() : pathToFinish; + QDir appDir(pathToFinish); + appDir.setFilter( QDir::Files | QDir::Dirs ); + + QFileInfoList dirEntries = appDir.entryInfoList(); + foreach (QFileInfo fi, dirEntries) + { + if ( fi.isDir() ) + { + QString dirname = fi.fileName(); + if ((dirname==".") || (dirname == "..")) + continue; + + // recursive clean up subdirectory + finishUpdate(fi.filePath()); + } + else + { + if(fi.suffix()=="oldversion") + if( !appDir.remove( fi.absoluteFilePath() ) ) + qDebug()<<"Error: Unable to clean up file: "<connectToHostEncrypted(urltoCheck.host(), 443); + if( !socket->waitForEncrypted(1000)) // waits until ssl emits encrypted(), max 1000msecs + { + qWarning()<<"SSL fingerprint check: Unable to connect SSL server: "<sslErrors(); + return false; + } + + QSslCertificate cert = socket->peerCertificate(); + + if(cert.isNull()) + { + qWarning()<<"SSL fingerprint check: Unable to retrieve SSL server certificate."; + return false; + } + + // COmpare digests + if(cert.digest().toHex() != m_requiredSslFingerprint) + { + qWarning()<<"SSL fingerprint check: FINGERPRINT MISMATCH! Server digest="<setUser(htAuthUsername); + authenticator->setPassword(htAuthPassword); +} + +void FvUpdater::setHtAuthCredentials(QString user, QString pass) +{ + htAuthUsername = user; + htAuthPassword = pass; +} + +void FvUpdater::setHtAuthUsername(QString user) +{ + htAuthUsername = user; +} + +void FvUpdater::setHtAuthPassword(QString pass) +{ + htAuthPassword = pass; +} + +void FvUpdater::setSkipVersionAllowed(bool allowed) +{ + skipVersionAllowed = allowed; +} + +void FvUpdater::setRemindLaterAllowed(bool allowed) +{ + remindLaterAllowed = allowed; +} + +bool FvUpdater::getSkipVersionAllowed() +{ + return skipVersionAllowed; +} + +bool FvUpdater::getRemindLaterAllowed() +{ + return remindLaterAllowed; +} + +#ifndef FV_GUI + +void FvUpdater::decideWhatToDoWithCurrentUpdateProposal() +{ + QString policy = settings->value(FV_NEW_VERSION_POLICY_KEY).toString(); + if(policy == "install") + InstallUpdate(); + else if(policy == "skip") + SkipUpdate(); + else + RemindMeLater(); +} + +#endif + diff --git a/interface/external/fervor/fvupdater.h b/interface/external/fervor/fvupdater.h new file mode 100755 index 0000000000..48baf0c194 --- /dev/null +++ b/interface/external/fervor/fvupdater.h @@ -0,0 +1,183 @@ +#ifndef FVUPDATER_H +#define FVUPDATER_H + +#include +#include +#include +#include +#include +class QNetworkReply; +class FvUpdateWindow; +class FvUpdateConfirmDialog; +class FvAvailableUpdate; + + +class FvUpdater : public QObject +{ + Q_OBJECT + +public: + + // Singleton + static FvUpdater* sharedUpdater(); + static void drop(); + + // Set / get feed URL + void SetFeedURL(QUrl feedURL); + void SetFeedURL(QString feedURL); + QString GetFeedURL(); + void finishUpdate(QString pathToFinish = ""); + void setRequiredSslFingerPrint(QString md5); + QString getRequiredSslFingerPrint(); // returns md5! + // HTTP Authentuication - for security reasons no getters are provided, only a setter + void setHtAuthCredentials(QString user, QString pass); + void setHtAuthUsername(QString user); + void setHtAuthPassword(QString pass); + void setSkipVersionAllowed(bool allowed); + void setRemindLaterAllowed(bool allowed); + bool getSkipVersionAllowed(); + bool getRemindLaterAllowed(); + + +public slots: + + // Check for updates + bool CheckForUpdates(bool silentAsMuchAsItCouldGet = true); + + // Aliases + bool CheckForUpdatesSilent(); + bool CheckForUpdatesNotSilent(); + + + // + // --------------------------------------------------- + // --------------------------------------------------- + // --------------------------------------------------- + // --------------------------------------------------- + // + +protected: + + friend class FvUpdateWindow; // Uses GetProposedUpdate() and others + friend class FvUpdateConfirmDialog; // Uses GetProposedUpdate() and others + FvAvailableUpdate* GetProposedUpdate(); + + +protected slots: + + // Update window button slots + void InstallUpdate(); + void SkipUpdate(); + void RemindMeLater(); + +private: + + // + // Singleton business + // + // (we leave just the declarations, so the compiler will warn us if we try + // to use those two functions by accident) + FvUpdater(); // Hide main constructor + ~FvUpdater(); // Hide main destructor + FvUpdater(const FvUpdater&); // Hide copy constructor + FvUpdater& operator=(const FvUpdater&); // Hide assign op + + static FvUpdater* m_Instance; // Singleton instance + + + // + // Windows / dialogs + // +#ifdef FV_GUI + FvUpdateWindow* m_updaterWindow; // Updater window (NULL if not shown) + void showUpdaterWindowUpdatedWithCurrentUpdateProposal(); // Show updater window + void hideUpdaterWindow(); // Hide + destroy m_updaterWindow + void updaterWindowWasClosed(); // Sent by the updater window when it gets closed +#else + void decideWhatToDoWithCurrentUpdateProposal(); // Perform an action which is configured in settings +#endif + + // Available update (NULL if not fetched) + FvAvailableUpdate* m_proposedUpdate; + + // If true, don't show the error dialogs and the "no updates." dialog + // (silentAsMuchAsItCouldGet from CheckForUpdates() goes here) + // Useful for automatic update checking upon application startup. + bool m_silentAsMuchAsItCouldGet; + + // Dialogs (notifications) + bool skipVersionAllowed; + bool remindLaterAllowed; + + void showErrorDialog(QString message, bool showEvenInSilentMode = false); // Show an error message + void showInformationDialog(QString message, bool showEvenInSilentMode = false); // Show an informational message + + + // + // HTTP feed fetcher infrastructure + // + QUrl m_feedURL; // Feed URL that will be fetched + QNetworkAccessManager m_qnam; + QNetworkReply* m_reply; + int m_httpGetId; + bool m_httpRequestAborted; + + void startDownloadFeed(QUrl url); // Start downloading feed + void cancelDownloadFeed(); // Stop downloading the current feed + + // + // SSL Fingerprint Check infrastructure + // + QString m_requiredSslFingerprint; + + bool checkSslFingerPrint(QUrl urltoCheck); // true=ssl Fingerprint accepted, false= ssl Fingerprint NOT accepted + + // + // Htauth-Infrastructure + // + QString htAuthUsername; + QString htAuthPassword; + + + // + // XML parser + // + QXmlStreamReader m_xml; // XML data collector and parser + bool xmlParseFeed(); // Parse feed in m_xml + bool searchDownloadedFeedForUpdates(QString xmlTitle, + QString xmlLink, + QString xmlReleaseNotesLink, + QString xmlPubDate, + QString xmlEnclosureUrl, + QString xmlEnclosureVersion, + QString xmlEnclosurePlatform, + unsigned long xmlEnclosureLength, + QString xmlEnclosureType); + + + // + // Helpers + // + void installTranslator(); // Initialize translation mechanism + void restartApplication(); // Restarts application after update + +private slots: + + void authenticationRequired ( QNetworkReply * reply, QAuthenticator * authenticator ); + void httpFeedReadyRead(); + void httpFeedUpdateDataReadProgress(qint64 bytesRead, + qint64 totalBytes); + void httpFeedDownloadFinished(); + + // + // Download and install Update infrastructure + // + void httpUpdateDownloadFinished(); + bool unzipUpdate(const QString & filePath, const QString & extDirPath, const QString & singleFileName = QString("")); // returns true on success + +signals: + void updatedFinishedSuccessfully(); + +}; + +#endif // FVUPDATER_H diff --git a/interface/external/fervor/fvupdatewindow.cpp b/interface/external/fervor/fvupdatewindow.cpp new file mode 100755 index 0000000000..75329a54f3 --- /dev/null +++ b/interface/external/fervor/fvupdatewindow.cpp @@ -0,0 +1,66 @@ +#include "fvupdatewindow.h" +#include "ui_fvupdatewindow.h" +#include "fvupdater.h" +#include "fvavailableupdate.h" +#include +#include +#include + + +FvUpdateWindow::FvUpdateWindow(QWidget *parent, bool skipVersionAllowed, bool remindLaterAllowed) : + QWidget(parent, Qt::CustomizeWindowHint), + m_ui(new Ui::FvUpdateWindow) +{ + m_ui->setupUi(this); + + m_appIconScene = 0; + + if(!skipVersionAllowed) + m_ui->skipThisVersionButton->hide(); + if(!remindLaterAllowed) + m_ui->remindMeLaterButton->hide(); + + // Delete on close + setAttribute(Qt::WA_DeleteOnClose, true); + + // Set the "new version is available" string + QString newVersString = m_ui->newVersionIsAvailableLabel->text().arg(QApplication::applicationName()); + m_ui->newVersionIsAvailableLabel->setText(newVersString); + + // Connect buttons + connect(m_ui->installUpdateButton, SIGNAL(clicked()), + FvUpdater::sharedUpdater(), SLOT(InstallUpdate())); + connect(m_ui->skipThisVersionButton, SIGNAL(clicked()), + FvUpdater::sharedUpdater(), SLOT(SkipUpdate())); + connect(m_ui->remindMeLaterButton, SIGNAL(clicked()), + FvUpdater::sharedUpdater(), SLOT(RemindMeLater())); +} + +FvUpdateWindow::~FvUpdateWindow() +{ + m_ui->releaseNotesWebView->stop(); + delete m_ui; +} + +bool FvUpdateWindow::UpdateWindowWithCurrentProposedUpdate() +{ + FvAvailableUpdate* proposedUpdate = FvUpdater::sharedUpdater()->GetProposedUpdate(); + if (! proposedUpdate) { + return false; + } + + QString downloadString = m_ui->wouldYouLikeToDownloadLabel->text() + .arg(QApplication::applicationName(), proposedUpdate->GetEnclosureVersion(), QApplication::applicationVersion()); + m_ui->wouldYouLikeToDownloadLabel->setText(downloadString); + + m_ui->releaseNotesWebView->stop(); + m_ui->releaseNotesWebView->load(proposedUpdate->GetReleaseNotesLink()); + + return true; +} + +void FvUpdateWindow::closeEvent(QCloseEvent* event) +{ + FvUpdater::sharedUpdater()->updaterWindowWasClosed(); + event->accept(); +} diff --git a/interface/external/fervor/fvupdatewindow.h b/interface/external/fervor/fvupdatewindow.h new file mode 100755 index 0000000000..b2e3feb443 --- /dev/null +++ b/interface/external/fervor/fvupdatewindow.h @@ -0,0 +1,37 @@ +#ifndef FVUPDATEWINDOW_H +#define FVUPDATEWINDOW_H + +#if QT_VERSION >= 0x050000 + #include +#else + #include +#endif + +class QGraphicsScene; + +namespace Ui { +class FvUpdateWindow; +} + +class FvUpdateWindow : public QWidget +{ + Q_OBJECT + +public: + explicit FvUpdateWindow(QWidget *parent, bool skipVersionAllowed, bool remindLaterAllowed); + ~FvUpdateWindow(); + + // Update the current update proposal from FvUpdater + bool UpdateWindowWithCurrentProposedUpdate(); + + void closeEvent(QCloseEvent* event); + +private: + Ui::FvUpdateWindow* m_ui; + QGraphicsScene* m_appIconScene; + +}; + +#endif // FVUPDATEWINDOW_H + + diff --git a/interface/external/fervor/fvupdatewindow.ui b/interface/external/fervor/fvupdatewindow.ui new file mode 100755 index 0000000000..c59646bde7 --- /dev/null +++ b/interface/external/fervor/fvupdatewindow.ui @@ -0,0 +1,129 @@ + + + FvUpdateWindow + + + + 0 + 0 + 640 + 480 + + + + Software Update + + + + QLayout::SetFixedSize + + + + + + + + 75 + true + + + + A new version of %1 is available! + + + + + + + %1 %2 is now available - you have %3. Would you like to download it now? + + + + + + + + 75 + true + + + + Release Notes: + + + + + + + 160 + 80 + + + + + about:blank + + + + + + + + + + + + + Skip This Version + + + + + + + Qt::Horizontal + + + + 40 + 20 + + + + + + + + Remind Me Later + + + + + + + Install Update + + + true + + + true + + + + + + + + + + + + QWebView + QWidget +
QtWebKit/QWebView
+
+
+ + +
diff --git a/interface/external/fervor/fvversioncomparator.cpp b/interface/external/fervor/fvversioncomparator.cpp new file mode 100755 index 0000000000..dc4da8a086 --- /dev/null +++ b/interface/external/fervor/fvversioncomparator.cpp @@ -0,0 +1,164 @@ +#include "fvversioncomparator.h" +#include +#include +#include + +// +// Clone of Sparkle's SUStandardVersionComparator.m, so here's original author's +// copyright too: +// +// Copyright 2007 Andy Matuschak. All rights reserved. +// +// Everything's the same except for TypeOfCharacter() +// (because who knows how Foundation does isdigit() and such.) +// + + +FvVersionComparator::FvVersionComparator() +{ + // noop +} + +FvVersionComparator::CharacterType FvVersionComparator::TypeOfCharacter(std::string character) +{ + if (character == ".") { + return kSeparatorType; + } else if (isdigit(character[0])) { + return kNumberType; + } else if (isspace(character[0])) { + return kSeparatorType; + } else if (ispunct(character[0])) { + return kSeparatorType; + } else { + return kStringType; + } + +} + +std::vector FvVersionComparator::SplitVersionString(std::string version) +{ + std::string character; + std::string s; + unsigned long i = 0, n = 0; + CharacterType oldType, newType; + std::vector parts; + + if (version.length() == 0) { + // Nothing to do here + return parts; + } + + s = version.substr(0, 1); + oldType = TypeOfCharacter(s); + n = version.length() - 1; + for (i = 1; i <= n; ++i) { + character = version.substr(i, 1)[0]; + newType = TypeOfCharacter(character); + if (oldType != newType || oldType == kSeparatorType) { + // We've reached a new segment + std::string aPart = s; + parts.push_back(aPart); + s = character; + } else { + // Add character to string and continue + s.append(character); + } + oldType = newType; + } + + // Add the last part onto the array + parts.push_back(s); + return parts; +} + + +FvVersionComparator::ComparatorResult FvVersionComparator::CompareVersions(std::string versionA, + std::string versionB) +{ + std::vector partsA = SplitVersionString(versionA); + std::vector partsB = SplitVersionString(versionB); + + std::string partA = std::string(""), partB = std::string(""); + unsigned long i = 0, n = 0; + int intA, intB; + CharacterType typeA, typeB; + + n = std::min(partsA.size(), partsB.size()); + for (i = 0; i < n; ++i) { + partA = partsA.at(i); + partB = partsB.at(i); + + typeA = TypeOfCharacter(partA); + typeB = TypeOfCharacter(partB); + + // Compare types + if (typeA == typeB) { + // Same type; we can compare + if (typeA == kNumberType) { + intA = atoi(partA.c_str()); + intB = atoi(partB.c_str()); + + if (intA > intB) { + return kDescending; + } else if (intA < intB) { + return kAscending; + } + } else if (typeA == kStringType) { + short result = partA.compare(partB); + switch (result) { + case -1: return kAscending; break; + case 1: return kDescending; break; + case 0: /* do nothing */ break; + }; + } + } else { + // Not the same type? Now we have to do some validity checking + if (typeA != kStringType && typeB == kStringType) { + // typeA wins + return kDescending; + } else if (typeA == kStringType && typeB != kStringType) { + // typeB wins + return kAscending; + } else { + // One is a number and the other is a period. The period is invalid + if (typeA == kNumberType) { + return kDescending; + } else { + return kAscending; + } + } + } + } + // The versions are equal up to the point where they both still have parts + // Lets check to see if one is larger than the other + if (partsA.size() != partsB.size()) { + // Yep. Lets get the next part of the larger + // n holds the index of the part we want. + std::string missingPart = std::string(""); + CharacterType missingType; + ComparatorResult shorterResult, largerResult; + + if (partsA.size() > partsB.size()) { + missingPart = partsA.at(n); + shorterResult = kAscending; + largerResult = kDescending; + } else { + missingPart = partsB.at(n); + shorterResult = kDescending; + largerResult = kAscending; + } + + missingType = TypeOfCharacter(missingPart); + // Check the type + if (missingType == kStringType) { + // It's a string. Shorter version wins + return shorterResult; + } else { + // It's a number/period. Larger version wins + return largerResult; + } + } + + // The 2 strings are identical + return kSame; +} diff --git a/interface/external/fervor/fvversioncomparator.h b/interface/external/fervor/fvversioncomparator.h new file mode 100755 index 0000000000..f083fdfe03 --- /dev/null +++ b/interface/external/fervor/fvversioncomparator.h @@ -0,0 +1,36 @@ +#ifndef FVVERSIONCOMPARATOR_H +#define FVVERSIONCOMPARATOR_H + +#include +#include + + +class FvVersionComparator +{ +public: + + typedef enum { + kSame = 0, + kDescending = 1, + kAscending = -1 + } ComparatorResult; + + static ComparatorResult CompareVersions(std::string versionA, + std::string versionB); + +private: + + FvVersionComparator(); + + typedef enum { + kNumberType, + kStringType, + kSeparatorType + } CharacterType; + + static CharacterType TypeOfCharacter(std::string character); + static std::vector SplitVersionString(std::string version); + +}; + +#endif // FVVERSIONCOMPARATOR_H diff --git a/interface/external/quazip/include/JlCompress.h b/interface/external/quazip/include/JlCompress.h new file mode 100644 index 0000000000..968f7a89ad --- /dev/null +++ b/interface/external/quazip/include/JlCompress.h @@ -0,0 +1,114 @@ +#ifndef JLCOMPRESSFOLDER_H_ +#define JLCOMPRESSFOLDER_H_ + +#include "quazip.h" +#include "quazipfile.h" +#include "quazipfileinfo.h" +#include +#include +#include +#include + +/// Utility class for typical operations. +/** + This class contains a number of useful static functions to perform + simple operations, such as mass ZIP packing or extraction. + */ +class QUAZIP_EXPORT JlCompress { +private: + /// Compress a single file. + /** + \param zip Opened zip to compress the file to. + \param fileName The full path to the source file. + \param fileDest The full name of the file inside the archive. + \return true if success, false otherwise. + */ + static bool compressFile(QuaZip* zip, QString fileName, QString fileDest); + /// Compress a subdirectory. + /** + \param parentZip Opened zip containing the parent directory. + \param dir The full path to the directory to pack. + \param parentDir The full path to the directory corresponding to + the root of the ZIP. + \param recursive Whether to pack sub-directories as well or only + files. + \return true if success, false otherwise. + */ + static bool compressSubDir(QuaZip* parentZip, QString dir, QString parentDir, bool recursive = true); + /// Extract a single file. + /** + \param zip The opened zip archive to extract from. + \param fileName The full name of the file to extract. + \param fileDest The full path to the destination file. + \return true if success, false otherwise. + */ + static bool extractFile(QuaZip* zip, QString fileName, QString fileDest); + /// Remove some files. + /** + \param listFile The list of files to remove. + \return true if success, false otherwise. + */ + static bool removeFile(QStringList listFile); + +public: + /// Compress a single file. + /** + \param fileCompressed The name of the archive. + \param file The file to compress. + \return true if success, false otherwise. + */ + static bool compressFile(QString fileCompressed, QString file); + /// Compress a list of files. + /** + \param fileCompressed The name of the archive. + \param files The file list to compress. + \return true if success, false otherwise. + */ + static bool compressFiles(QString fileCompressed, QStringList files); + /// Compress a whole directory. + /** + \param fileCompressed The name of the archive. + \param dir The directory to compress. + \param recursive Whether to pack the subdirectories as well, or + just regular files. + \return true if success, false otherwise. + */ + static bool compressDir(QString fileCompressed, QString dir = QString(), bool recursive = true); + +public: + /// Extract a single file. + /** + \param fileCompressed The name of the archive. + \param fileName The file to extract. + \param fileDest The destination file, assumed to be identical to + \a file if left empty. + \return The list of the full paths of the files extracted, empty on failure. + */ + static QString extractFile(QString fileCompressed, QString fileName, QString fileDest = QString()); + /// Extract a list of files. + /** + \param fileCompressed The name of the archive. + \param files The file list to extract. + \param dir The directory to put the files to, the current + directory if left empty. + \return The list of the full paths of the files extracted, empty on failure. + */ + static QStringList extractFiles(QString fileCompressed, QStringList files, QString dir = QString()); + /// Extract a whole archive. + /** + \param fileCompressed The name of the archive. + \param dir The directory to extract to, the current directory if + left empty. + \return The list of the full paths of the files extracted, empty on failure. + */ + static QStringList extractDir(QString fileCompressed, QString dir = QString()); + /// Get the file list. + /** + \return The list of the files in the archive, or, more precisely, the + list of the entries, including both files and directories if they + are present separately. + */ + static QStringList getFileList(QString fileCompressed); +}; + +#endif /* JLCOMPRESSFOLDER_H_ */ diff --git a/interface/external/quazip/include/crypt.h b/interface/external/quazip/include/crypt.h new file mode 100644 index 0000000000..1d6da628f3 --- /dev/null +++ b/interface/external/quazip/include/crypt.h @@ -0,0 +1,135 @@ +/* crypt.h -- base code for crypt/uncrypt ZIPfile + + + Version 1.01e, February 12th, 2005 + + Copyright (C) 1998-2005 Gilles Vollant + + This code is a modified version of crypting code in Infozip distribution + + The encryption/decryption parts of this source code (as opposed to the + non-echoing password parts) were originally written in Europe. The + whole source package can be freely distributed, including from the USA. + (Prior to January 2000, re-export from the US was a violation of US law.) + + This encryption code is a direct transcription of the algorithm from + Roger Schlafly, described by Phil Katz in the file appnote.txt. This + file (appnote.txt) is distributed with the PKZIP program (even in the + version without encryption capabilities). + + If you don't need crypting in your application, just define symbols + NOCRYPT and NOUNCRYPT. + + This code support the "Traditional PKWARE Encryption". + + The new AES encryption added on Zip format by Winzip (see the page + http://www.winzip.com/aes_info.htm ) and PKWare PKZip 5.x Strong + Encryption is not supported. +*/ + +#include "quazip_global.h" + +#define CRC32(c, b) ((*(pcrc_32_tab+(((int)(c) ^ (b)) & 0xff))) ^ ((c) >> 8)) + +/*********************************************************************** + * Return the next byte in the pseudo-random sequence + */ +static int decrypt_byte(unsigned long* pkeys, const unsigned long* pcrc_32_tab UNUSED) +{ + //(void) pcrc_32_tab; /* avoid "unused parameter" warning */ + unsigned temp; /* POTENTIAL BUG: temp*(temp^1) may overflow in an + * unpredictable manner on 16-bit systems; not a problem + * with any known compiler so far, though */ + + temp = ((unsigned)(*(pkeys+2)) & 0xffff) | 2; + return (int)(((temp * (temp ^ 1)) >> 8) & 0xff); +} + +/*********************************************************************** + * Update the encryption keys with the next byte of plain text + */ +static int update_keys(unsigned long* pkeys,const unsigned long* pcrc_32_tab,int c) +{ + (*(pkeys+0)) = CRC32((*(pkeys+0)), c); + (*(pkeys+1)) += (*(pkeys+0)) & 0xff; + (*(pkeys+1)) = (*(pkeys+1)) * 134775813L + 1; + { + register int keyshift = (int)((*(pkeys+1)) >> 24); + (*(pkeys+2)) = CRC32((*(pkeys+2)), keyshift); + } + return c; +} + + +/*********************************************************************** + * Initialize the encryption keys and the random header according to + * the given password. + */ +static void init_keys(const char* passwd,unsigned long* pkeys,const unsigned long* pcrc_32_tab) +{ + *(pkeys+0) = 305419896L; + *(pkeys+1) = 591751049L; + *(pkeys+2) = 878082192L; + while (*passwd != '\0') { + update_keys(pkeys,pcrc_32_tab,(int)*passwd); + passwd++; + } +} + +#define zdecode(pkeys,pcrc_32_tab,c) \ + (update_keys(pkeys,pcrc_32_tab,c ^= decrypt_byte(pkeys,pcrc_32_tab))) + +#define zencode(pkeys,pcrc_32_tab,c,t) \ + (t=decrypt_byte(pkeys,pcrc_32_tab), update_keys(pkeys,pcrc_32_tab,c), t^(c)) + +#ifdef INCLUDECRYPTINGCODE_IFCRYPTALLOWED + +#define RAND_HEAD_LEN 12 + /* "last resort" source for second part of crypt seed pattern */ +# ifndef ZCR_SEED2 +# define ZCR_SEED2 3141592654UL /* use PI as default pattern */ +# endif + +static int crypthead(passwd, buf, bufSize, pkeys, pcrc_32_tab, crcForCrypting) + const char *passwd; /* password string */ + unsigned char *buf; /* where to write header */ + int bufSize; + unsigned long* pkeys; + const unsigned long* pcrc_32_tab; + unsigned long crcForCrypting; +{ + int n; /* index in random header */ + int t; /* temporary */ + int c; /* random byte */ + unsigned char header[RAND_HEAD_LEN-2]; /* random header */ + static unsigned calls = 0; /* ensure different random header each time */ + + if (bufSize> 7) & 0xff; + header[n] = (unsigned char)zencode(pkeys, pcrc_32_tab, c, t); + } + /* Encrypt random header (last two bytes is high word of crc) */ + init_keys(passwd, pkeys, pcrc_32_tab); + for (n = 0; n < RAND_HEAD_LEN-2; n++) + { + buf[n] = (unsigned char)zencode(pkeys, pcrc_32_tab, header[n], t); + } + buf[n++] = zencode(pkeys, pcrc_32_tab, (int)(crcForCrypting >> 16) & 0xff, t); + buf[n++] = zencode(pkeys, pcrc_32_tab, (int)(crcForCrypting >> 24) & 0xff, t); + return n; +} + +#endif diff --git a/interface/external/quazip/include/ioapi.h b/interface/external/quazip/include/ioapi.h new file mode 100644 index 0000000000..f4c2180932 --- /dev/null +++ b/interface/external/quazip/include/ioapi.h @@ -0,0 +1,77 @@ +/* ioapi.h -- IO base function header for compress/uncompress .zip + files using zlib + zip or unzip API + + Version 1.01e, February 12th, 2005 + + Copyright (C) 1998-2005 Gilles Vollant + + Modified by Sergey A. Tachenov to integrate with Qt. +*/ + +#ifndef _ZLIBIOAPI_H +#define _ZLIBIOAPI_H + + +#define ZLIB_FILEFUNC_SEEK_CUR (1) +#define ZLIB_FILEFUNC_SEEK_END (2) +#define ZLIB_FILEFUNC_SEEK_SET (0) + +#define ZLIB_FILEFUNC_MODE_READ (1) +#define ZLIB_FILEFUNC_MODE_WRITE (2) +#define ZLIB_FILEFUNC_MODE_READWRITEFILTER (3) + +#define ZLIB_FILEFUNC_MODE_EXISTING (4) +#define ZLIB_FILEFUNC_MODE_CREATE (8) + + +#ifndef ZCALLBACK + +#if (defined(WIN32) || defined (WINDOWS) || defined (_WINDOWS)) && defined(CALLBACK) && defined (USEWINDOWS_CALLBACK) +#define ZCALLBACK CALLBACK +#else +#define ZCALLBACK +#endif +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +typedef voidpf (ZCALLBACK *open_file_func) OF((voidpf opaque, voidpf file, int mode)); +typedef uLong (ZCALLBACK *read_file_func) OF((voidpf opaque, voidpf stream, void* buf, uLong size)); +typedef uLong (ZCALLBACK *write_file_func) OF((voidpf opaque, voidpf stream, const void* buf, uLong size)); +typedef uLong (ZCALLBACK *tell_file_func) OF((voidpf opaque, voidpf stream)); +typedef int (ZCALLBACK *seek_file_func) OF((voidpf opaque, voidpf stream, uLong offset, int origin)); +typedef int (ZCALLBACK *close_file_func) OF((voidpf opaque, voidpf stream)); +typedef int (ZCALLBACK *testerror_file_func) OF((voidpf opaque, voidpf stream)); + +typedef struct zlib_filefunc_def_s +{ + open_file_func zopen_file; + read_file_func zread_file; + write_file_func zwrite_file; + tell_file_func ztell_file; + seek_file_func zseek_file; + close_file_func zclose_file; + testerror_file_func zerror_file; + voidpf opaque; +} zlib_filefunc_def; + + + +void fill_qiodevice_filefunc OF((zlib_filefunc_def* pzlib_filefunc_def)); + +#define ZREAD(filefunc,filestream,buf,size) ((*((filefunc).zread_file))((filefunc).opaque,filestream,buf,size)) +#define ZWRITE(filefunc,filestream,buf,size) ((*((filefunc).zwrite_file))((filefunc).opaque,filestream,buf,size)) +#define ZTELL(filefunc,filestream) ((*((filefunc).ztell_file))((filefunc).opaque,filestream)) +#define ZSEEK(filefunc,filestream,pos,mode) ((*((filefunc).zseek_file))((filefunc).opaque,filestream,pos,mode)) +#define ZCLOSE(filefunc,filestream) ((*((filefunc).zclose_file))((filefunc).opaque,filestream)) +#define ZERROR(filefunc,filestream) ((*((filefunc).zerror_file))((filefunc).opaque,filestream)) + + +#ifdef __cplusplus +} +#endif + +#endif + diff --git a/interface/external/quazip/include/quaadler32.h b/interface/external/quazip/include/quaadler32.h new file mode 100644 index 0000000000..643e38361e --- /dev/null +++ b/interface/external/quazip/include/quaadler32.h @@ -0,0 +1,29 @@ +#ifndef QUAADLER32_H +#define QUAADLER32_H + +#include + +#include "quachecksum32.h" + +/// Adler32 checksum +/** \class QuaAdler32 quaadler32.h + * This class wrappers the adler32 function with the QuaChecksum32 interface. + * See QuaChecksum32 for more info. + */ +class QUAZIP_EXPORT QuaAdler32 : public QuaChecksum32 +{ + +public: + QuaAdler32(); + + quint32 calculate(const QByteArray &data); + + void reset(); + void update(const QByteArray &buf); + quint32 value(); + +private: + quint32 checksum; +}; + +#endif //QUAADLER32_H diff --git a/interface/external/quazip/include/quachecksum32.h b/interface/external/quazip/include/quachecksum32.h new file mode 100644 index 0000000000..6837d26b86 --- /dev/null +++ b/interface/external/quazip/include/quachecksum32.h @@ -0,0 +1,54 @@ +#ifndef QUACHECKSUM32_H +#define QUACHECKSUM32_H + +#include +#include "quazip_global.h" + +/// Checksum interface. +/** \class QuaChecksum32 quachecksum32.h + * This is an interface for 32 bit checksums. + * Classes implementing this interface can calcunate a certin + * checksum in a single step: + * \code + * QChecksum32 *crc32 = new QuaCrc32(); + * rasoult = crc32->calculate(data); + * \endcode + * or by streaming the data: + * \code + * QChecksum32 *crc32 = new QuaCrc32(); + * while(!fileA.atEnd()) + * crc32->update(fileA.read(bufSize)); + * resoultA = crc32->value(); + * crc32->reset(); + * while(!fileB.atEnd()) + * crc32->update(fileB.read(bufSize)); + * resoultB = crc32->value(); + * \endcode + */ +class QUAZIP_EXPORT QuaChecksum32 +{ + +public: + ///Calculates the checksum for data. + /** \a data source data + * \return data checksum + * + * This function has no efect on the value returned by value(). + */ + virtual quint32 calculate(const QByteArray &data) = 0; + + ///Resets the calculation on a checksun for a stream. + virtual void reset() = 0; + + ///Updates the calculated checksum for the stream + /** \a buf next portion of data from the stream + */ + virtual void update(const QByteArray &buf) = 0; + + ///Value of the checksum calculated for the stream passed throw update(). + /** \return checksum + */ + virtual quint32 value() = 0; +}; + +#endif //QUACHECKSUM32_H diff --git a/interface/external/quazip/include/quacrc32.h b/interface/external/quazip/include/quacrc32.h new file mode 100644 index 0000000000..4c86d56657 --- /dev/null +++ b/interface/external/quazip/include/quacrc32.h @@ -0,0 +1,26 @@ +#ifndef QUACRC32_H +#define QUACRC32_H + +#include "quachecksum32.h" + +///CRC32 checksum +/** \class QuaCrc32 quacrc32.h +* This class wrappers the crc32 function with the QuaChecksum32 interface. +* See QuaChecksum32 for more info. +*/ +class QUAZIP_EXPORT QuaCrc32 : public QuaChecksum32 { + +public: + QuaCrc32(); + + quint32 calculate(const QByteArray &data); + + void reset(); + void update(const QByteArray &buf); + quint32 value(); + +private: + quint32 checksum; +}; + +#endif //QUACRC32_H diff --git a/interface/external/quazip/include/quagzipfile.h b/interface/external/quazip/include/quagzipfile.h new file mode 100644 index 0000000000..0a71173824 --- /dev/null +++ b/interface/external/quazip/include/quagzipfile.h @@ -0,0 +1,84 @@ +#ifndef QUAZIP_QUAGZIPFILE_H +#define QUAZIP_QUAGZIPFILE_H + +#include +#include "quazip_global.h" + +#include + +class QuaGzipFilePrivate; + +/// GZIP file +/** + This class is a wrapper around GZIP file access functions in zlib. Unlike QuaZip classes, it doesn't allow reading from a GZIP file opened as QIODevice, for example, if your GZIP file is in QBuffer. It only provides QIODevice access to a GZIP file contents, but the GZIP file itself must be identified by its name on disk or by descriptor id. + */ +class QUAZIP_EXPORT QuaGzipFile: public QIODevice { + Q_OBJECT +public: + /// Empty constructor. + /** + Must call setFileName() before trying to open. + */ + QuaGzipFile(); + /// Empty constructor with a parent. + /** + Must call setFileName() before trying to open. + \param parent The parent object, as per QObject logic. + */ + QuaGzipFile(QObject *parent); + /// Constructor. + /** + \param fileName The name of the GZIP file. + \param parent The parent object, as per QObject logic. + */ + QuaGzipFile(const QString &fileName, QObject *parent = NULL); + /// Destructor. + virtual ~QuaGzipFile(); + /// Sets the name of the GZIP file to be opened. + void setFileName(const QString& fileName); + /// Returns the name of the GZIP file. + QString getFileName() const; + /// Returns true. + /** + Strictly speaking, zlib supports seeking for GZIP files, but it is + poorly implemented, because there is no way to implement it + properly. For reading, seeking backwards is very slow, and for + writing, it is downright impossible. Therefore, QuaGzipFile does not + support seeking at all. + */ + virtual bool isSequential() const; + /// Opens the file. + /** + \param mode Can be either QIODevice::Write or QIODevice::Read. + ReadWrite and Append aren't supported. + */ + virtual bool open(QIODevice::OpenMode mode); + /// Opens the file. + /** + \overload + \param fd The file descriptor to read/write the GZIP file from/to. + \param mode Can be either QIODevice::Write or QIODevice::Read. + ReadWrite and Append aren't supported. + */ + virtual bool open(int fd, QIODevice::OpenMode mode); + /// Flushes data to file. + /** + The data is written using Z_SYNC_FLUSH mode. Doesn't make any sense + when reading. + */ + virtual bool flush(); + /// Closes the file. + virtual void close(); +protected: + /// Implementation of QIODevice::readData(). + virtual qint64 readData(char *data, qint64 maxSize); + /// Implementation of QIODevice::writeData(). + virtual qint64 writeData(const char *data, qint64 maxSize); +private: + // not implemented by design to disable copy + QuaGzipFile(const QuaGzipFile &that); + QuaGzipFile& operator=(const QuaGzipFile &that); + QuaGzipFilePrivate *d; +}; + +#endif // QUAZIP_QUAGZIPFILE_H diff --git a/interface/external/quazip/include/quaziodevice.h b/interface/external/quazip/include/quaziodevice.h new file mode 100644 index 0000000000..ff0d31a5c4 --- /dev/null +++ b/interface/external/quazip/include/quaziodevice.h @@ -0,0 +1,74 @@ +#ifndef QUAZIP_QUAZIODEVICE_H +#define QUAZIP_QUAZIODEVICE_H + +#include +#include "quazip_global.h" + +#include + +class QuaZIODevicePrivate; + +/// A class to compress/decompress QIODevice. +/** + This class can be used to compress any data written to QIODevice or + decompress it back. Compressing data sent over a QTcpSocket is a good + example. + */ +class QUAZIP_EXPORT QuaZIODevice: public QIODevice { + Q_OBJECT +public: + /// Constructor. + /** + \param io The QIODevice to read/write. + \param parent The parent object, as per QObject logic. + */ + QuaZIODevice(QIODevice *io, QObject *parent = NULL); + /// Destructor. + ~QuaZIODevice(); + /// Flushes data waiting to be written. + /** + Unfortunately, as QIODevice doesn't support flush() by itself, the + only thing this method does is write the compressed data into the + device using Z_SYNC_FLUSH mode. If you need the compressed data to + actually be flushed from the buffer of the underlying QIODevice, you + need to call its flush() method as well, providing it supports it + (like QTcpSocket does). Example: + \code + QuaZIODevice dev(&sock); + dev.open(QIODevice::Write); + dev.write(yourDataGoesHere); + dev.flush(); + sock->flush(); // this actually sends data to network + \endcode + + This may change in the future versions of QuaZIP by implementing an + ugly hack: trying to cast the QIODevice using qobject_cast to known + flush()-supporting subclasses, and calling flush if the resulting + pointer is not zero. + */ + virtual bool flush(); + /// Opens the device. + /** + \param mode Neither QIODevice::ReadWrite nor QIODevice::Append are + not supported. + */ + virtual bool open(QIODevice::OpenMode mode); + /// Closes this device, but not the underlying one. + /** + The underlying QIODevice is not closed in case you want to write + something else to it. + */ + virtual void close(); + /// Returns the underlying device. + QIODevice *getIoDevice() const; + /// Returns true. + virtual bool isSequential() const; +protected: + /// Implementation of QIODevice::readData(). + virtual qint64 readData(char *data, qint64 maxSize); + /// Implementation of QIODevice::writeData(). + virtual qint64 writeData(const char *data, qint64 maxSize); +private: + QuaZIODevicePrivate *d; +}; +#endif // QUAZIP_QUAZIODEVICE_H diff --git a/interface/external/quazip/include/quazip.h b/interface/external/quazip/include/quazip.h new file mode 100644 index 0000000000..4daa322b5f --- /dev/null +++ b/interface/external/quazip/include/quazip.h @@ -0,0 +1,419 @@ +#ifndef QUA_ZIP_H +#define QUA_ZIP_H + +/* +Copyright (C) 2005-2011 Sergey A. Tachenov + +This program 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 of the License, or (at +your option) any later version. + +This program is distributed in the hope that it will be useful, but +WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser +General Public License for more details. + +You should have received a copy of the GNU Lesser General Public License +along with this program; if not, write to the Free Software Foundation, +Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + +See COPYING file for the full LGPL text. + +Original ZIP package is copyrighted by Gilles Vollant, see +quazip/(un)zip.h files for details, basically it's zlib license. + **/ + +#include +#include +#include + +#include "zip.h" +#include "unzip.h" + +#include "quazip_global.h" +#include "quazipfileinfo.h" + +// just in case it will be defined in the later versions of the ZIP/UNZIP +#ifndef UNZ_OPENERROR +// define additional error code +#define UNZ_OPENERROR -1000 +#endif + +class QuaZipPrivate; + +/// ZIP archive. +/** \class QuaZip quazip.h + * This class implements basic interface to the ZIP archive. It can be + * used to read table contents of the ZIP archive and retreiving + * information about the files inside it. + * + * You can also use this class to open files inside archive by passing + * pointer to the instance of this class to the constructor of the + * QuaZipFile class. But see QuaZipFile::QuaZipFile(QuaZip*, QObject*) + * for the possible pitfalls. + * + * This class is indended to provide interface to the ZIP subpackage of + * the ZIP/UNZIP package as well as to the UNZIP subpackage. But + * currently it supports only UNZIP. + * + * The use of this class is simple - just create instance using + * constructor, then set ZIP archive file name using setFile() function + * (if you did not passed the name to the constructor), then open() and + * then use different functions to work with it! Well, if you are + * paranoid, you may also wish to call close before destructing the + * instance, to check for errors on close. + * + * You may also use getUnzFile() and getZipFile() functions to get the + * ZIP archive handle and use it with ZIP/UNZIP package API directly. + * + * This class supports localized file names inside ZIP archive, but you + * have to set up proper codec with setCodec() function. By default, + * locale codec will be used, which is probably ok for UNIX systems, but + * will almost certainly fail with ZIP archives created in Windows. This + * is because Windows ZIP programs have strange habit of using DOS + * encoding for file names in ZIP archives. For example, ZIP archive + * with cyrillic names created in Windows will have file names in \c + * IBM866 encoding instead of \c WINDOWS-1251. I think that calling one + * function is not much trouble, but for true platform independency it + * would be nice to have some mechanism for file name encoding auto + * detection using locale information. Does anyone know a good way to do + * it? + **/ +class QUAZIP_EXPORT QuaZip { + friend class QuaZipPrivate; + public: + /// Useful constants. + enum Constants { + MAX_FILE_NAME_LENGTH=256 /**< Maximum file name length. Taken from + \c UNZ_MAXFILENAMEINZIP constant in + unzip.c. */ + }; + /// Open mode of the ZIP file. + enum Mode { + mdNotOpen, ///< ZIP file is not open. This is the initial mode. + mdUnzip, ///< ZIP file is open for reading files inside it. + mdCreate, ///< ZIP file was created with open() call. + mdAppend, /**< ZIP file was opened in append mode. This refers to + * \c APPEND_STATUS_CREATEAFTER mode in ZIP/UNZIP package + * and means that zip is appended to some existing file + * what is useful when that file contains + * self-extractor code. This is obviously \em not what + * you whant to use to add files to the existing ZIP + * archive. + **/ + mdAdd ///< ZIP file was opened for adding files in the archive. + }; + /// Case sensitivity for the file names. + /** This is what you specify when accessing files in the archive. + * Works perfectly fine with any characters thanks to Qt's great + * unicode support. This is different from ZIP/UNZIP API, where + * only US-ASCII characters was supported. + **/ + enum CaseSensitivity { + csDefault=0, ///< Default for platform. Case sensitive for UNIX, not for Windows. + csSensitive=1, ///< Case sensitive. + csInsensitive=2 ///< Case insensitive. + }; + /// Returns the actual case sensitivity for the specified QuaZIP one. + /** + \param cs The value to convert. + \returns If CaseSensitivity::csDefault, then returns the default + file name case sensitivity for the platform. Otherwise, just + returns the appropriate value from the Qt::CaseSensitivity enum. + */ + static Qt::CaseSensitivity convertCaseSensitivity( + CaseSensitivity cs); + private: + QuaZipPrivate *p; + // not (and will not be) implemented + QuaZip(const QuaZip& that); + // not (and will not be) implemented + QuaZip& operator=(const QuaZip& that); + public: + /// Constructs QuaZip object. + /** Call setName() before opening constructed object. */ + QuaZip(); + /// Constructs QuaZip object associated with ZIP file \a zipName. + QuaZip(const QString& zipName); + /// Constructs QuaZip object associated with ZIP file represented by \a ioDevice. + /** The IO device must be seekable, otherwise an error will occur when opening. */ + QuaZip(QIODevice *ioDevice); + /// Destroys QuaZip object. + /** Calls close() if necessary. */ + ~QuaZip(); + /// Opens ZIP file. + /** + * Argument \a mode specifies open mode of the ZIP archive. See Mode + * for details. Note that there is zipOpen2() function in the + * ZIP/UNZIP API which accepts \a globalcomment argument, but it + * does not use it anywhere, so this open() function does not have this + * argument. See setComment() if you need to set global comment. + * + * If the ZIP file is accessed via explicitly set QIODevice, then + * this device is opened in the necessary mode. If the device was + * already opened by some other means, then the behaviour is defined by + * the device implementation, but generally it is not a very good + * idea. For example, QFile will at least issue a warning. + * + * \return \c true if successful, \c false otherwise. + * + * \note ZIP/UNZIP API open calls do not return error code - they + * just return \c NULL indicating an error. But to make things + * easier, quazip.h header defines additional error code \c + * UNZ_ERROROPEN and getZipError() will return it if the open call + * of the ZIP/UNZIP API returns \c NULL. + * + * Argument \a ioApi specifies IO function set for ZIP/UNZIP + * package to use. See unzip.h, zip.h and ioapi.h for details. Note + * that IO API for QuaZip is different from the original package. + * The file path argument was changed to be of type \c voidpf, and + * QuaZip passes a QIODevice pointer there. This QIODevice is either + * set explicitly via setIoDevice() or the QuaZip(QIODevice*) + * constructor, or it is created internally when opening the archive + * by its file name. The default API (qioapi.cpp) just delegates + * everything to the QIODevice API. Not only this allows to use a + * QIODevice instead of file name, but also has a nice side effect + * of raising the file size limit from 2G to 4G. + * + * In short: just forget about the \a ioApi argument and you'll be + * fine. + **/ + bool open(Mode mode, zlib_filefunc_def *ioApi =NULL); + /// Closes ZIP file. + /** Call getZipError() to determine if the close was successful. The + * underlying QIODevice is also closed, regardless of whether it was + * set explicitly or not. */ + void close(); + /// Sets the codec used to encode/decode file names inside archive. + /** This is necessary to access files in the ZIP archive created + * under Windows with non-latin characters in file names. For + * example, file names with cyrillic letters will be in \c IBM866 + * encoding. + **/ + void setFileNameCodec(QTextCodec *fileNameCodec); + /// Sets the codec used to encode/decode file names inside archive. + /** \overload + * Equivalent to calling setFileNameCodec(QTextCodec::codecForName(codecName)); + **/ + void setFileNameCodec(const char *fileNameCodecName); + /// Returns the codec used to encode/decode comments inside archive. + QTextCodec* getFileNameCodec() const; + /// Sets the codec used to encode/decode comments inside archive. + /** This codec defaults to locale codec, which is probably ok. + **/ + void setCommentCodec(QTextCodec *commentCodec); + /// Sets the codec used to encode/decode comments inside archive. + /** \overload + * Equivalent to calling setCommentCodec(QTextCodec::codecForName(codecName)); + **/ + void setCommentCodec(const char *commentCodecName); + /// Returns the codec used to encode/decode comments inside archive. + QTextCodec* getCommentCodec() const; + /// Returns the name of the ZIP file. + /** Returns null string if no ZIP file name has been set, for + * example when the QuaZip instance is set up to use a QIODevice + * instead. + * \sa setZipName(), setIoDevice(), getIoDevice() + **/ + QString getZipName() const; + /// Sets the name of the ZIP file. + /** Does nothing if the ZIP file is open. + * + * Does not reset error code returned by getZipError(). + * \sa setIoDevice(), getIoDevice(), getZipName() + **/ + void setZipName(const QString& zipName); + /// Returns the device representing this ZIP file. + /** Returns null string if no device has been set explicitly, for + * example when opening a ZIP file by name. + * \sa setIoDevice(), getZipName(), setZipName() + **/ + QIODevice *getIoDevice() const; + /// Sets the device representing the ZIP file. + /** Does nothing if the ZIP file is open. + * + * Does not reset error code returned by getZipError(). + * \sa getIoDevice(), getZipName(), setZipName() + **/ + void setIoDevice(QIODevice *ioDevice); + /// Returns the mode in which ZIP file was opened. + Mode getMode() const; + /// Returns \c true if ZIP file is open, \c false otherwise. + bool isOpen() const; + /// Returns the error code of the last operation. + /** Returns \c UNZ_OK if the last operation was successful. + * + * Error code resets to \c UNZ_OK every time you call any function + * that accesses something inside ZIP archive, even if it is \c + * const (like getEntriesCount()). open() and close() calls reset + * error code too. See documentation for the specific functions for + * details on error detection. + **/ + int getZipError() const; + /// Returns number of the entries in the ZIP central directory. + /** Returns negative error code in the case of error. The same error + * code will be returned by subsequent getZipError() call. + **/ + int getEntriesCount() const; + /// Returns global comment in the ZIP file. + QString getComment() const; + /// Sets the global comment in the ZIP file. + /** The comment will be written to the archive on close operation. + * QuaZip makes a distinction between a null QByteArray() comment + * and an empty "" comment in the QuaZip::mdAdd mode. + * A null comment is the default and it means "don't change + * the comment". An empty comment removes the original comment. + * + * \sa open() + **/ + void setComment(const QString& comment); + /// Sets the current file to the first file in the archive. + /** Returns \c true on success, \c false otherwise. Call + * getZipError() to get the error code. + **/ + bool goToFirstFile(); + /// Sets the current file to the next file in the archive. + /** Returns \c true on success, \c false otherwise. Call + * getZipError() to determine if there was an error. + * + * Should be used only in QuaZip::mdUnzip mode. + * + * \note If the end of file was reached, getZipError() will return + * \c UNZ_OK instead of \c UNZ_END_OF_LIST_OF_FILE. This is to make + * things like this easier: + * \code + * for(bool more=zip.goToFirstFile(); more; more=zip.goToNextFile()) { + * // do something + * } + * if(zip.getZipError()==UNZ_OK) { + * // ok, there was no error + * } + * \endcode + **/ + bool goToNextFile(); + /// Sets current file by its name. + /** Returns \c true if successful, \c false otherwise. Argument \a + * cs specifies case sensitivity of the file name. Call + * getZipError() in the case of a failure to get error code. + * + * This is not a wrapper to unzLocateFile() function. That is + * because I had to implement locale-specific case-insensitive + * comparison. + * + * Here are the differences from the original implementation: + * + * - If the file was not found, error code is \c UNZ_OK, not \c + * UNZ_END_OF_LIST_OF_FILE (see also goToNextFile()). + * - If this function fails, it unsets the current file rather than + * resetting it back to what it was before the call. + * + * If \a fileName is null string then this function unsets the + * current file and return \c true. Note that you should close the + * file first if it is open! See + * QuaZipFile::QuaZipFile(QuaZip*,QObject*) for the details. + * + * Should be used only in QuaZip::mdUnzip mode. + * + * \sa setFileNameCodec(), CaseSensitivity + **/ + bool setCurrentFile(const QString& fileName, CaseSensitivity cs =csDefault); + /// Returns \c true if the current file has been set. + bool hasCurrentFile() const; + /// Retrieves information about the current file. + /** Fills the structure pointed by \a info. Returns \c true on + * success, \c false otherwise. In the latter case structure pointed + * by \a info remains untouched. If there was an error, + * getZipError() returns error code. + * + * Should be used only in QuaZip::mdUnzip mode. + * + * Does nothing and returns \c false in any of the following cases. + * - ZIP is not open; + * - ZIP does not have current file; + * - \a info is \c NULL; + * + * In all these cases getZipError() returns \c UNZ_OK since there + * is no ZIP/UNZIP API call. + **/ + bool getCurrentFileInfo(QuaZipFileInfo* info)const; + /// Returns the current file name. + /** Equivalent to calling getCurrentFileInfo() and then getting \c + * name field of the QuaZipFileInfo structure, but faster and more + * convenient. + * + * Should be used only in QuaZip::mdUnzip mode. + **/ + QString getCurrentFileName()const; + /// Returns \c unzFile handle. + /** You can use this handle to directly call UNZIP part of the + * ZIP/UNZIP package functions (see unzip.h). + * + * \warning When using the handle returned by this function, please + * keep in mind that QuaZip class is unable to detect any changes + * you make in the ZIP file state (e. g. changing current file, or + * closing the handle). So please do not do anything with this + * handle that is possible to do with the functions of this class. + * Or at least return the handle in the original state before + * calling some another function of this class (including implicit + * destructor calls and calls from the QuaZipFile objects that refer + * to this QuaZip instance!). So if you have changed the current + * file in the ZIP archive - then change it back or you may + * experience some strange behavior or even crashes. + **/ + unzFile getUnzFile(); + /// Returns \c zipFile handle. + /** You can use this handle to directly call ZIP part of the + * ZIP/UNZIP package functions (see zip.h). Warnings about the + * getUnzFile() function also apply to this function. + **/ + zipFile getZipFile(); + /// Changes the data descriptor writing mode. + /** + According to the ZIP format specification, a file inside archive + may have a data descriptor immediately following the file + data. This is reflected by a special flag in the local file header + and in the central directory. By default, QuaZIP sets this flag + and writes the data descriptor unless both method and level were + set to 0, in which case it operates in 1.0-compatible mode and + never writes data descriptors. + + By setting this flag to false, it is possible to disable data + descriptor writing, thus increasing compatibility with archive + readers that don't understand this feature of the ZIP file format. + + Setting this flag affects all the QuaZipFile instances that are + opened after this flag is set. + + The data descriptor writing mode is enabled by default. + + \param enabled If \c true, enable local descriptor writing, + disable it otherwise. + + \sa QuaZipFile::setDataDescriptorWritingEnabled() + */ + void setDataDescriptorWritingEnabled(bool enabled); + /// Returns the data descriptor default writing mode. + /** + \sa setDataDescriptorWritingEnabled() + */ + bool isDataDescriptorWritingEnabled() const; + /// Returns a list of files inside the archive. + /** + \return A list of file names or an empty list if there + was an error or if the archive is empty (call getZipError() to + figure out which). + \sa getFileInfoList() + */ + QStringList getFileNameList() const; + /// Returns information list about all files inside the archive. + /** + \return A list of QuaZipFileInfo objects or an empty list if there + was an error or if the archive is empty (call getZipError() to + figure out which). + \sa getFileNameList() + */ + QList getFileInfoList() const; +}; + +#endif diff --git a/interface/external/quazip/include/quazip_global.h b/interface/external/quazip/include/quazip_global.h new file mode 100644 index 0000000000..d9d09ade18 --- /dev/null +++ b/interface/external/quazip/include/quazip_global.h @@ -0,0 +1,55 @@ +/** +Copyright (C) 2005-2011 Sergey A. Tachenov + +This program 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 of the License, or (at +your option) any later version. + +This program is distributed in the hope that it will be useful, but +WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser +General Public License for more details. + +You should have received a copy of the GNU Lesser General Public License +along with this program; if not, write to the Free Software Foundation, +Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + +See COPYING file for the full LGPL text. + +Original ZIP package is copyrighted by Gilles Vollant, see +quazip/(un)zip.h files for details, basically it's zlib license. + */ + +#ifndef QUAZIP_GLOBAL_H +#define QUAZIP_GLOBAL_H + +#include + +/** + This is automatically defined when building a static library, but when + including QuaZip sources directly into a project, QUAZIP_STATIC should + be defined explicitly to avoid possible troubles with unnecessary + importing/exporting. + */ +#ifdef QUAZIP_STATIC +#define QUAZIP_EXPORT +#else +/** + * When building a DLL with MSVC, QUAZIP_BUILD must be defined. + * qglobal.h takes care of defining Q_DECL_* correctly for msvc/gcc. + */ +#if defined(QUAZIP_BUILD) + #define QUAZIP_EXPORT Q_DECL_EXPORT +#else + #define QUAZIP_EXPORT Q_DECL_IMPORT +#endif +#endif // QUAZIP_STATIC + +#ifdef __GNUC__ +#define UNUSED __attribute__((__unused__)) +#else +#define UNUSED +#endif + +#endif // QUAZIP_GLOBAL_H diff --git a/interface/external/quazip/include/quazipdir.h b/interface/external/quazip/include/quazipdir.h new file mode 100644 index 0000000000..e2d70bc888 --- /dev/null +++ b/interface/external/quazip/include/quazipdir.h @@ -0,0 +1,171 @@ +#ifndef QUAZIP_QUAZIPDIR_H +#define QUAZIP_QUAZIPDIR_H + +class QuaZipDirPrivate; + +#include "quazip.h" +#include "quazipfileinfo.h" +#include +#include +#include + +/// Provides ZIP archive navigation. +/** +* This class is modelled after QDir, and is designed to provide similar +* features for ZIP archives. +* +* The only significant difference from QDir is that the root path is not +* '/', but an empty string since that's how the file paths are stored in +* the archive. However, QuaZipDir understands the paths starting with +* '/'. It is important in a few places: +* +* - In the cd() function. +* - In the constructor. +* - In the exists() function. +* +* Note that since ZIP uses '/' on all platforms, the '\' separator is +* not supported. +*/ +class QUAZIP_EXPORT QuaZipDir { +private: + QSharedDataPointer d; +public: + /// The copy constructor. + QuaZipDir(const QuaZipDir &that); + /// Constructs a QuaZipDir instance pointing to the specified directory. + /** + If \a dir is not specified, points to the root of the archive. + The same happens if the \a dir is "/". + */ + QuaZipDir(QuaZip *zip, const QString &dir = QString()); + /// Destructor. + ~QuaZipDir(); + /// The assignment operator. + bool operator==(const QuaZipDir &that); + /// operator!= + /** + \return \c true if either this and \a that use different QuaZip + instances or if they point to different directories. + */ + inline bool operator!=(const QuaZipDir &that) {return !operator==(that);} + /// operator== + /** + \return \c true if both this and \a that use the same QuaZip + instance and point to the same directory. + */ + QuaZipDir& operator=(const QuaZipDir &that); + /// Returns the name of the entry at the specified position. + QString operator[](int pos) const; + /// Returns the current case sensitivity mode. + QuaZip::CaseSensitivity caseSensitivity() const; + /// Changes the 'current' directory. + /** + * If the path starts with '/', it is interpreted as an absolute + * path from the root of the archive. Otherwise, it is interpreted + * as a path relative to the current directory as was set by the + * previous cd() or the constructor. + * + * Note that the subsequent path() call will not return a path + * starting with '/' in all cases. + */ + bool cd(const QString &dirName); + /// Goes up. + bool cdUp(); + /// Returns the number of entries in the directory. + uint count() const; + /// Returns the current directory name. + /** + The name doesn't include the path. + */ + QString dirName() const; + /// Returns the list of the entries in the directory. + /** + \param nameFilters The list of file patterns to list, uses the same + syntax as QDir. + \param filters The entry type filters, only Files and Dirs are + accepted. + \param sort Sorting mode (not supported yet). + */ + QList entryInfoList(const QStringList &nameFilters, + QDir::Filters filters = QDir::NoFilter, + QDir::SortFlags sort = QDir::NoSort) const; + /// Returns the list of the entries in the directory. + /** + \overload + + The same as entryInfoList(QStringList(), filters, sort). + */ + QList entryInfoList(QDir::Filters filters = QDir::NoFilter, + QDir::SortFlags sort = QDir::NoSort) const; + /// Returns the list of the entry names in the directory. + /** + The same as entryInfoList(nameFilters, filters, sort), but only + returns entry names. + */ + QStringList entryList(const QStringList &nameFilters, + QDir::Filters filters = QDir::NoFilter, + QDir::SortFlags sort = QDir::NoSort) const; + /// Returns the list of the entry names in the directory. + /** + \overload + + The same as entryList(QStringList(), filters, sort). + */ + QStringList entryList(QDir::Filters filters = QDir::NoFilter, + QDir::SortFlags sort = QDir::NoSort) const; + /// Returns \c true if the entry with the specified name exists. + /** + The ".." is considered to exist if the current directory + is not root. The "." and "/" are considered to + always exist. Paths starting with "/" are relative to + the archive root, other paths are relative to the current dir. + */ + bool exists(const QString &fileName) const; + /// Return \c true if the directory pointed by this QuaZipDir exists. + bool exists() const; + /// Returns the full path to the specified file. + /** + Doesn't check if the file actually exists. + */ + QString filePath(const QString &fileName) const; + /// Returns the default filter. + QDir::Filters filter(); + /// Returns if the QuaZipDir points to the root of the archive. + /** + Not that the root path is the empty string, not '/'. + */ + bool isRoot() const; + /// Return the default name filter. + QStringList nameFilters() const; + /// Returns the path to the current dir. + /** + The path never starts with '/', and the root path is an empty + string. + */ + QString path() const; + /// Returns the path to the specified file relative to the current dir. + QString relativeFilePath(const QString &fileName) const; + /// Sets the default case sensitivity mode. + void setCaseSensitivity(QuaZip::CaseSensitivity caseSensitivity); + /// Sets the default filter. + void setFilter(QDir::Filters filters); + /// Sets the default name filter. + void setNameFilters(const QStringList &nameFilters); + /// Goes to the specified path. + /** + The difference from cd() is that this function never checks if the + path actually exists and doesn't use relative paths, so it's + possible to go to the root directory with setPath(""). + + Note that this function still chops the trailing and/or leading + '/' and treats a single '/' as the root path (path() will still + return an empty string). + */ + void setPath(const QString &path); + /// Sets the default sorting mode. + void setSorting(QDir::SortFlags sort); + /// Returns the default sorting mode. + QDir::SortFlags sorting() const; +}; + +#endif // QUAZIP_QUAZIPDIR_H diff --git a/interface/external/quazip/include/quazipfile.h b/interface/external/quazip/include/quazipfile.h new file mode 100644 index 0000000000..f6cc41a6bc --- /dev/null +++ b/interface/external/quazip/include/quazipfile.h @@ -0,0 +1,442 @@ +#ifndef QUA_ZIPFILE_H +#define QUA_ZIPFILE_H + +/* +Copyright (C) 2005-2011 Sergey A. Tachenov + +This program 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 of the License, or (at +your option) any later version. + +This program is distributed in the hope that it will be useful, but +WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser +General Public License for more details. + +You should have received a copy of the GNU Lesser General Public License +along with this program; if not, write to the Free Software Foundation, +Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + +See COPYING file for the full LGPL text. + +Original ZIP package is copyrighted by Gilles Vollant, see +quazip/(un)zip.h files for details, basically it's zlib license. + **/ + +#include + +#include "quazip_global.h" +#include "quazip.h" +#include "quazipnewinfo.h" + +class QuaZipFilePrivate; + +/// A file inside ZIP archive. +/** \class QuaZipFile quazipfile.h + * This is the most interesting class. Not only it provides C++ + * interface to the ZIP/UNZIP package, but also integrates it with Qt by + * subclassing QIODevice. This makes possible to access files inside ZIP + * archive using QTextStream or QDataStream, for example. Actually, this + * is the main purpose of the whole QuaZIP library. + * + * You can either use existing QuaZip instance to create instance of + * this class or pass ZIP archive file name to this class, in which case + * it will create internal QuaZip object. See constructors' descriptions + * for details. Writing is only possible with the existing instance. + * + * Note that due to the underlying library's limitation it is not + * possible to use multiple QuaZipFile instances to open several files + * in the same archive at the same time. If you need to write to + * multiple files in parallel, then you should write to temporary files + * first, then pack them all at once when you have finished writing. If + * you need to read multiple files inside the same archive in parallel, + * you should extract them all into a temporary directory first. + * + * \section quazipfile-sequential Sequential or random-access? + * + * At the first thought, QuaZipFile has fixed size, the start and the + * end and should be therefore considered random-access device. But + * there is one major obstacle to making it random-access: ZIP/UNZIP API + * does not support seek() operation and the only way to implement it is + * through reopening the file and re-reading to the required position, + * but this is prohibitively slow. + * + * Therefore, QuaZipFile is considered to be a sequential device. This + * has advantage of availability of the ungetChar() operation (QIODevice + * does not implement it properly for non-sequential devices unless they + * support seek()). Disadvantage is a somewhat strange behaviour of the + * size() and pos() functions. This should be kept in mind while using + * this class. + * + **/ +class QUAZIP_EXPORT QuaZipFile: public QIODevice { + friend class QuaZipFilePrivate; + Q_OBJECT + private: + QuaZipFilePrivate *p; + // these are not supported nor implemented + QuaZipFile(const QuaZipFile& that); + QuaZipFile& operator=(const QuaZipFile& that); + protected: + /// Implementation of the QIODevice::readData(). + qint64 readData(char *data, qint64 maxSize); + /// Implementation of the QIODevice::writeData(). + qint64 writeData(const char *data, qint64 maxSize); + public: + /// Constructs a QuaZipFile instance. + /** You should use setZipName() and setFileName() or setZip() before + * trying to call open() on the constructed object. + **/ + QuaZipFile(); + /// Constructs a QuaZipFile instance. + /** \a parent argument specifies this object's parent object. + * + * You should use setZipName() and setFileName() or setZip() before + * trying to call open() on the constructed object. + **/ + QuaZipFile(QObject *parent); + /// Constructs a QuaZipFile instance. + /** \a parent argument specifies this object's parent object and \a + * zipName specifies ZIP archive file name. + * + * You should use setFileName() before trying to call open() on the + * constructed object. + * + * QuaZipFile constructed by this constructor can be used for read + * only access. Use QuaZipFile(QuaZip*,QObject*) for writing. + **/ + QuaZipFile(const QString& zipName, QObject *parent =NULL); + /// Constructs a QuaZipFile instance. + /** \a parent argument specifies this object's parent object, \a + * zipName specifies ZIP archive file name and \a fileName and \a cs + * specify a name of the file to open inside archive. + * + * QuaZipFile constructed by this constructor can be used for read + * only access. Use QuaZipFile(QuaZip*,QObject*) for writing. + * + * \sa QuaZip::setCurrentFile() + **/ + QuaZipFile(const QString& zipName, const QString& fileName, + QuaZip::CaseSensitivity cs =QuaZip::csDefault, QObject *parent =NULL); + /// Constructs a QuaZipFile instance. + /** \a parent argument specifies this object's parent object. + * + * \a zip is the pointer to the existing QuaZip object. This + * QuaZipFile object then can be used to read current file in the + * \a zip or to write to the file inside it. + * + * \warning Using this constructor for reading current file can be + * tricky. Let's take the following example: + * \code + * QuaZip zip("archive.zip"); + * zip.open(QuaZip::mdUnzip); + * zip.setCurrentFile("file-in-archive"); + * QuaZipFile file(&zip); + * file.open(QIODevice::ReadOnly); + * // ok, now we can read from the file + * file.read(somewhere, some); + * zip.setCurrentFile("another-file-in-archive"); // oops... + * QuaZipFile anotherFile(&zip); + * anotherFile.open(QIODevice::ReadOnly); + * anotherFile.read(somewhere, some); // this is still ok... + * file.read(somewhere, some); // and this is NOT + * \endcode + * So, what exactly happens here? When we change current file in the + * \c zip archive, \c file that references it becomes invalid + * (actually, as far as I understand ZIP/UNZIP sources, it becomes + * closed, but QuaZipFile has no means to detect it). + * + * Summary: do not close \c zip object or change its current file as + * long as QuaZipFile is open. Even better - use another constructors + * which create internal QuaZip instances, one per object, and + * therefore do not cause unnecessary trouble. This constructor may + * be useful, though, if you already have a QuaZip instance and do + * not want to access several files at once. Good example: + * \code + * QuaZip zip("archive.zip"); + * zip.open(QuaZip::mdUnzip); + * // first, we need some information about archive itself + * QByteArray comment=zip.getComment(); + * // and now we are going to access files inside it + * QuaZipFile file(&zip); + * for(bool more=zip.goToFirstFile(); more; more=zip.goToNextFile()) { + * file.open(QIODevice::ReadOnly); + * // do something cool with file here + * file.close(); // do not forget to close! + * } + * zip.close(); + * \endcode + **/ + QuaZipFile(QuaZip *zip, QObject *parent =NULL); + /// Destroys a QuaZipFile instance. + /** Closes file if open, destructs internal QuaZip object (if it + * exists and \em is internal, of course). + **/ + virtual ~QuaZipFile(); + /// Returns the ZIP archive file name. + /** If this object was created by passing QuaZip pointer to the + * constructor, this function will return that QuaZip's file name + * (or null string if that object does not have file name yet). + * + * Otherwise, returns associated ZIP archive file name or null + * string if there are no name set yet. + * + * \sa setZipName() getFileName() + **/ + QString getZipName()const; + /// Returns a pointer to the associated QuaZip object. + /** Returns \c NULL if there is no associated QuaZip or it is + * internal (so you will not mess with it). + **/ + QuaZip* getZip()const; + /// Returns file name. + /** This function returns file name you passed to this object either + * by using + * QuaZipFile(const QString&,const QString&,QuaZip::CaseSensitivity,QObject*) + * or by calling setFileName(). Real name of the file may differ in + * case if you used case-insensitivity. + * + * Returns null string if there is no file name set yet. This is the + * case when this QuaZipFile operates on the existing QuaZip object + * (constructor QuaZipFile(QuaZip*,QObject*) or setZip() was used). + * + * \sa getActualFileName + **/ + QString getFileName() const; + /// Returns case sensitivity of the file name. + /** This function returns case sensitivity argument you passed to + * this object either by using + * QuaZipFile(const QString&,const QString&,QuaZip::CaseSensitivity,QObject*) + * or by calling setFileName(). + * + * Returns unpredictable value if getFileName() returns null string + * (this is the case when you did not used setFileName() or + * constructor above). + * + * \sa getFileName + **/ + QuaZip::CaseSensitivity getCaseSensitivity() const; + /// Returns the actual file name in the archive. + /** This is \em not a ZIP archive file name, but a name of file inside + * archive. It is not necessary the same name that you have passed + * to the + * QuaZipFile(const QString&,const QString&,QuaZip::CaseSensitivity,QObject*), + * setFileName() or QuaZip::setCurrentFile() - this is the real file + * name inside archive, so it may differ in case if the file name + * search was case-insensitive. + * + * Equivalent to calling getCurrentFileName() on the associated + * QuaZip object. Returns null string if there is no associated + * QuaZip object or if it does not have a current file yet. And this + * is the case if you called setFileName() but did not open the + * file yet. So this is perfectly fine: + * \code + * QuaZipFile file("somezip.zip"); + * file.setFileName("somefile"); + * QString name=file.getName(); // name=="somefile" + * QString actual=file.getActualFileName(); // actual is null string + * file.open(QIODevice::ReadOnly); + * QString actual=file.getActualFileName(); // actual can be "SoMeFiLe" on Windows + * \endcode + * + * \sa getZipName(), getFileName(), QuaZip::CaseSensitivity + **/ + QString getActualFileName()const; + /// Sets the ZIP archive file name. + /** Automatically creates internal QuaZip object and destroys + * previously created internal QuaZip object, if any. + * + * Will do nothing if this file is already open. You must close() it + * first. + **/ + void setZipName(const QString& zipName); + /// Returns \c true if the file was opened in raw mode. + /** If the file is not open, the returned value is undefined. + * + * \sa open(OpenMode,int*,int*,bool,const char*) + **/ + bool isRaw() const; + /// Binds to the existing QuaZip instance. + /** This function destroys internal QuaZip object, if any, and makes + * this QuaZipFile to use current file in the \a zip object for any + * further operations. See QuaZipFile(QuaZip*,QObject*) for the + * possible pitfalls. + * + * Will do nothing if the file is currently open. You must close() + * it first. + **/ + void setZip(QuaZip *zip); + /// Sets the file name. + /** Will do nothing if at least one of the following conditions is + * met: + * - ZIP name has not been set yet (getZipName() returns null + * string). + * - This QuaZipFile is associated with external QuaZip. In this + * case you should call that QuaZip's setCurrentFile() function + * instead! + * - File is already open so setting the name is meaningless. + * + * \sa QuaZip::setCurrentFile + **/ + void setFileName(const QString& fileName, QuaZip::CaseSensitivity cs =QuaZip::csDefault); + /// Opens a file for reading. + /** Returns \c true on success, \c false otherwise. + * Call getZipError() to get error code. + * + * \note Since ZIP/UNZIP API provides buffered reading only, + * QuaZipFile does not support unbuffered reading. So do not pass + * QIODevice::Unbuffered flag in \a mode, or open will fail. + **/ + virtual bool open(OpenMode mode); + /// Opens a file for reading. + /** \overload + * Argument \a password specifies a password to decrypt the file. If + * it is NULL then this function behaves just like open(OpenMode). + **/ + inline bool open(OpenMode mode, const char *password) + {return open(mode, NULL, NULL, false, password);} + /// Opens a file for reading. + /** \overload + * Argument \a password specifies a password to decrypt the file. + * + * An integers pointed by \a method and \a level will receive codes + * of the compression method and level used. See unzip.h. + * + * If raw is \c true then no decompression is performed. + * + * \a method should not be \c NULL. \a level can be \c NULL if you + * don't want to know the compression level. + **/ + bool open(OpenMode mode, int *method, int *level, bool raw, const char *password =NULL); + /// Opens a file for writing. + /** \a info argument specifies information about file. It should at + * least specify a correct file name. Also, it is a good idea to + * specify correct timestamp (by default, current time will be + * used). See QuaZipNewInfo. + * + * The \a password argument specifies the password for crypting. Pass NULL + * if you don't need any crypting. The \a crc argument was supposed + * to be used for crypting too, but then it turned out that it's + * false information, so you need to set it to 0 unless you want to + * use the raw mode (see below). + * + * Arguments \a method and \a level specify compression method and + * level. The only method supported is Z_DEFLATED, but you may also + * specify 0 for no compression. If all of the files in the archive + * use both method 0 and either level 0 is explicitly specified or + * data descriptor writing is disabled with + * QuaZip::setDataDescriptorWritingEnabled(), then the + * resulting archive is supposed to be compatible with the 1.0 ZIP + * format version, should you need that. Except for this, \a level + * has no other effects with method 0. + * + * If \a raw is \c true, no compression is performed. In this case, + * \a crc and uncompressedSize field of the \a info are required. + * + * Arguments \a windowBits, \a memLevel, \a strategy provide zlib + * algorithms tuning. See deflateInit2() in zlib. + **/ + bool open(OpenMode mode, const QuaZipNewInfo& info, + const char *password =NULL, quint32 crc =0, + int method =Z_DEFLATED, int level =Z_DEFAULT_COMPRESSION, bool raw =false, + int windowBits =-MAX_WBITS, int memLevel =DEF_MEM_LEVEL, int strategy =Z_DEFAULT_STRATEGY); + /// Returns \c true, but \ref quazipfile-sequential "beware"! + virtual bool isSequential()const; + /// Returns current position in the file. + /** Implementation of the QIODevice::pos(). When reading, this + * function is a wrapper to the ZIP/UNZIP unztell(), therefore it is + * unable to keep track of the ungetChar() calls (which is + * non-virtual and therefore is dangerous to reimplement). So if you + * are using ungetChar() feature of the QIODevice, this function + * reports incorrect value until you get back characters which you + * ungot. + * + * When writing, pos() returns number of bytes already written + * (uncompressed unless you use raw mode). + * + * \note Although + * \ref quazipfile-sequential "QuaZipFile is a sequential device" + * and therefore pos() should always return zero, it does not, + * because it would be misguiding. Keep this in mind. + * + * This function returns -1 if the file or archive is not open. + * + * Error code returned by getZipError() is not affected by this + * function call. + **/ + virtual qint64 pos()const; + /// Returns \c true if the end of file was reached. + /** This function returns \c false in the case of error. This means + * that you called this function on either not open file, or a file + * in the not open archive or even on a QuaZipFile instance that + * does not even have QuaZip instance associated. Do not do that + * because there is no means to determine whether \c false is + * returned because of error or because end of file was reached. + * Well, on the other side you may interpret \c false return value + * as "there is no file open to check for end of file and there is + * no end of file therefore". + * + * When writing, this function always returns \c true (because you + * are always writing to the end of file). + * + * Error code returned by getZipError() is not affected by this + * function call. + **/ + virtual bool atEnd()const; + /// Returns file size. + /** This function returns csize() if the file is open for reading in + * raw mode, usize() if it is open for reading in normal mode and + * pos() if it is open for writing. + * + * Returns -1 on error, call getZipError() to get error code. + * + * \note This function returns file size despite that + * \ref quazipfile-sequential "QuaZipFile is considered to be sequential device", + * for which size() should return bytesAvailable() instead. But its + * name would be very misguiding otherwise, so just keep in mind + * this inconsistence. + **/ + virtual qint64 size()const; + /// Returns compressed file size. + /** Equivalent to calling getFileInfo() and then getting + * compressedSize field, but more convenient and faster. + * + * File must be open for reading before calling this function. + * + * Returns -1 on error, call getZipError() to get error code. + **/ + qint64 csize()const; + /// Returns uncompressed file size. + /** Equivalent to calling getFileInfo() and then getting + * uncompressedSize field, but more convenient and faster. See + * getFileInfo() for a warning. + * + * File must be open for reading before calling this function. + * + * Returns -1 on error, call getZipError() to get error code. + **/ + qint64 usize()const; + /// Gets information about current file. + /** This function does the same thing as calling + * QuaZip::getCurrentFileInfo() on the associated QuaZip object, + * but you can not call getCurrentFileInfo() if the associated + * QuaZip is internal (because you do not have access to it), while + * you still can call this function in that case. + * + * File must be open for reading before calling this function. + * + * Returns \c false in the case of an error. + **/ + bool getFileInfo(QuaZipFileInfo *info); + /// Closes the file. + /** Call getZipError() to determine if the close was successful. + **/ + virtual void close(); + /// Returns the error code returned by the last ZIP/UNZIP API call. + int getZipError() const; + /// Returns the number of bytes available for reading. + virtual qint64 bytesAvailable() const; +}; + +#endif diff --git a/interface/external/quazip/include/quazipfileinfo.h b/interface/external/quazip/include/quazipfileinfo.h new file mode 100644 index 0000000000..327425f13e --- /dev/null +++ b/interface/external/quazip/include/quazipfileinfo.h @@ -0,0 +1,73 @@ +#ifndef QUA_ZIPFILEINFO_H +#define QUA_ZIPFILEINFO_H + +/* +Copyright (C) 2005-2011 Sergey A. Tachenov + +This program 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 of the License, or (at +your option) any later version. + +This program is distributed in the hope that it will be useful, but +WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser +General Public License for more details. + +You should have received a copy of the GNU Lesser General Public License +along with this program; if not, write to the Free Software Foundation, +Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + +See COPYING file for the full LGPL text. + +Original ZIP package is copyrighted by Gilles Vollant, see +quazip/(un)zip.h files for details, basically it's zlib license. + **/ + +#include +#include +#include + +#include "quazip_global.h" + +/// Information about a file inside archive. +/** Call QuaZip::getCurrentFileInfo() or QuaZipFile::getFileInfo() to + * fill this structure. */ +struct QUAZIP_EXPORT QuaZipFileInfo { + /// File name. + QString name; + /// Version created by. + quint16 versionCreated; + /// Version needed to extract. + quint16 versionNeeded; + /// General purpose flags. + quint16 flags; + /// Compression method. + quint16 method; + /// Last modification date and time. + QDateTime dateTime; + /// CRC. + quint32 crc; + /// Compressed file size. + quint32 compressedSize; + /// Uncompressed file size. + quint32 uncompressedSize; + /// Disk number start. + quint16 diskNumberStart; + /// Internal file attributes. + quint16 internalAttr; + /// External file attributes. + quint32 externalAttr; + /// Comment. + QString comment; + /// Extra field. + QByteArray extra; + /// Get the file permissions. + /** + Returns the high 16 bits of external attributes converted to + QFile::Permissions. + */ + QFile::Permissions getPermissions() const; +}; + +#endif diff --git a/interface/external/quazip/include/quazipnewinfo.h b/interface/external/quazip/include/quazipnewinfo.h new file mode 100644 index 0000000000..cd321c2712 --- /dev/null +++ b/interface/external/quazip/include/quazipnewinfo.h @@ -0,0 +1,121 @@ +#ifndef QUA_ZIPNEWINFO_H +#define QUA_ZIPNEWINFO_H + +/* +Copyright (C) 2005-2011 Sergey A. Tachenov + +This program 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 of the License, or (at +your option) any later version. + +This program is distributed in the hope that it will be useful, but +WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser +General Public License for more details. + +You should have received a copy of the GNU Lesser General Public License +along with this program; if not, write to the Free Software Foundation, +Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + +See COPYING file for the full LGPL text. + +Original ZIP package is copyrighted by Gilles Vollant, see +quazip/(un)zip.h files for details, basically it's zlib license. + **/ + +#include +#include + +#include "quazip_global.h" + +/// Information about a file to be created. +/** This structure holds information about a file to be created inside + * ZIP archive. At least name should be set to something correct before + * passing this structure to + * QuaZipFile::open(OpenMode,const QuaZipNewInfo&,int,int,bool). + **/ +struct QUAZIP_EXPORT QuaZipNewInfo { + /// File name. + /** This field holds file name inside archive, including path relative + * to archive root. + **/ + QString name; + /// File timestamp. + /** This is the last file modification date and time. Will be stored + * in the archive central directory. It is a good practice to set it + * to the source file timestamp instead of archive creating time. Use + * setFileDateTime() or QuaZipNewInfo(const QString&, const QString&). + **/ + QDateTime dateTime; + /// File internal attributes. + quint16 internalAttr; + /// File external attributes. + /** + The highest 16 bits contain Unix file permissions and type (dir or + file). The constructor QuaZipNewInfo(const QString&, const QString&) + takes permissions from the provided file. + */ + quint32 externalAttr; + /// File comment. + /** Will be encoded using QuaZip::getCommentCodec(). + **/ + QString comment; + /// File local extra field. + QByteArray extraLocal; + /// File global extra field. + QByteArray extraGlobal; + /// Uncompressed file size. + /** This is only needed if you are using raw file zipping mode, i. e. + * adding precompressed file in the zip archive. + **/ + ulong uncompressedSize; + /// Constructs QuaZipNewInfo instance. + /** Initializes name with \a name, dateTime with current date and + * time. Attributes are initialized with zeros, comment and extra + * field with null values. + **/ + QuaZipNewInfo(const QString& name); + /// Constructs QuaZipNewInfo instance. + /** Initializes name with \a name. Timestamp and permissions are taken + * from the specified file. If the \a file does not exists or its timestamp + * is inaccessible (e. g. you do not have read permission for the + * directory file in), uses current time and zero permissions. Other attributes are + * initialized with zeros, comment and extra field with null values. + * + * \sa setFileDateTime() + **/ + QuaZipNewInfo(const QString& name, const QString& file); + /// Sets the file timestamp from the existing file. + /** Use this function to set the file timestamp from the existing + * file. Use it like this: + * \code + * QuaZipFile zipFile(&zip); + * QFile file("file-to-add"); + * file.open(QIODevice::ReadOnly); + * QuaZipNewInfo info("file-name-in-archive"); + * info.setFileDateTime("file-to-add"); // take the timestamp from file + * zipFile.open(QIODevice::WriteOnly, info); + * \endcode + * + * This function does not change dateTime if some error occured (e. g. + * file is inaccessible). + **/ + void setFileDateTime(const QString& file); + /// Sets the file permissions from the existing file. + /** + Takes permissions from the file and sets the high 16 bits of + external attributes. Uses QFileInfo to get permissions on all + platforms. + */ + void setFilePermissions(const QString &file); + /// Sets the file permissions. + /** + Modifies the highest 16 bits of external attributes. The type part + is set to dir if the name ends with a slash, and to regular file + otherwise. + */ + void setPermissions(QFile::Permissions permissions); +}; + +#endif diff --git a/interface/external/quazip/include/unzip.h b/interface/external/quazip/include/unzip.h new file mode 100644 index 0000000000..33c9dc1ab3 --- /dev/null +++ b/interface/external/quazip/include/unzip.h @@ -0,0 +1,356 @@ +/* unzip.h -- IO for uncompress .zip files using zlib + Version 1.01e, February 12th, 2005 + + Copyright (C) 1998-2005 Gilles Vollant + + This unzip package allow extract file from .ZIP file, compatible with PKZip 2.04g + WinZip, InfoZip tools and compatible. + + Multi volume ZipFile (span) are not supported. + Encryption compatible with pkzip 2.04g only supported + Old compressions used by old PKZip 1.x are not supported + + + I WAIT FEEDBACK at mail info@winimage.com + Visit also http://www.winimage.com/zLibDll/unzip.htm for evolution + + Condition of use and distribution are the same than zlib : + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. + + Modified by Sergey A. Tachenov to integrate with Qt. + + +*/ + +/* for more info about .ZIP format, see + http://www.info-zip.org/pub/infozip/doc/appnote-981119-iz.zip + http://www.info-zip.org/pub/infozip/doc/ + PkWare has also a specification at : + ftp://ftp.pkware.com/probdesc.zip +*/ + +#ifndef _unz_H +#define _unz_H + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef _ZLIB_H +#include "zlib.h" +#endif + +#ifndef _ZLIBIOAPI_H +#include "ioapi.h" +#endif + +#if defined(STRICTUNZIP) || defined(STRICTZIPUNZIP) +/* like the STRICT of WIN32, we define a pointer that cannot be converted + from (void*) without cast */ +typedef struct TagunzFile__ { int unused; } unzFile__; +typedef unzFile__ *unzFile; +#else +typedef voidp unzFile; +#endif + + +#define UNZ_OK (0) +#define UNZ_END_OF_LIST_OF_FILE (-100) +#define UNZ_ERRNO (Z_ERRNO) +#define UNZ_EOF (0) +#define UNZ_PARAMERROR (-102) +#define UNZ_BADZIPFILE (-103) +#define UNZ_INTERNALERROR (-104) +#define UNZ_CRCERROR (-105) + +/* tm_unz contain date/time info */ +typedef struct tm_unz_s +{ + uInt tm_sec; /* seconds after the minute - [0,59] */ + uInt tm_min; /* minutes after the hour - [0,59] */ + uInt tm_hour; /* hours since midnight - [0,23] */ + uInt tm_mday; /* day of the month - [1,31] */ + uInt tm_mon; /* months since January - [0,11] */ + uInt tm_year; /* years - [1980..2044] */ +} tm_unz; + +/* unz_global_info structure contain global data about the ZIPfile + These data comes from the end of central dir */ +typedef struct unz_global_info_s +{ + uLong number_entry; /* total number of entries in + the central dir on this disk */ + uLong size_comment; /* size of the global comment of the zipfile */ +} unz_global_info; + + +/* unz_file_info contain information about a file in the zipfile */ +typedef struct unz_file_info_s +{ + uLong version; /* version made by 2 bytes */ + uLong version_needed; /* version needed to extract 2 bytes */ + uLong flag; /* general purpose bit flag 2 bytes */ + uLong compression_method; /* compression method 2 bytes */ + uLong dosDate; /* last mod file date in Dos fmt 4 bytes */ + uLong crc; /* crc-32 4 bytes */ + uLong compressed_size; /* compressed size 4 bytes */ + uLong uncompressed_size; /* uncompressed size 4 bytes */ + uLong size_filename; /* filename length 2 bytes */ + uLong size_file_extra; /* extra field length 2 bytes */ + uLong size_file_comment; /* file comment length 2 bytes */ + + uLong disk_num_start; /* disk number start 2 bytes */ + uLong internal_fa; /* internal file attributes 2 bytes */ + uLong external_fa; /* external file attributes 4 bytes */ + + tm_unz tmu_date; +} unz_file_info; + +extern int ZEXPORT unzStringFileNameCompare OF ((const char* fileName1, + const char* fileName2, + int iCaseSensitivity)); +/* + Compare two filename (fileName1,fileName2). + If iCaseSenisivity = 1, comparision is case sensitivity (like strcmp) + If iCaseSenisivity = 2, comparision is not case sensitivity (like strcmpi + or strcasecmp) + If iCaseSenisivity = 0, case sensitivity is defaut of your operating system + (like 1 on Unix, 2 on Windows) +*/ + + +extern unzFile ZEXPORT unzOpen OF((voidpf file)); +/* + Open a Zip file. path contain whatever zopen_file from the IO API + accepts. For Qt implementation it is a pointer to QIODevice, for + fopen() implementation it's a file name. + If the zipfile cannot be opened (file don't exist or in not valid), the + return value is NULL. + Else, the return value is a unzFile Handle, usable with other function + of this unzip package. +*/ + +extern unzFile ZEXPORT unzOpen2 OF((voidpf file, + zlib_filefunc_def* pzlib_filefunc_def)); +/* + Open a Zip file, like unzOpen, but provide a set of file low level API + for read/write the zip file (see ioapi.h) +*/ + +extern int ZEXPORT unzClose OF((unzFile file)); +/* + Close a ZipFile opened with unzipOpen. + If there is files inside the .Zip opened with unzOpenCurrentFile (see later), + these files MUST be closed with unzipCloseCurrentFile before call unzipClose. + return UNZ_OK if there is no problem. */ + +extern int ZEXPORT unzGetGlobalInfo OF((unzFile file, + unz_global_info *pglobal_info)); +/* + Write info about the ZipFile in the *pglobal_info structure. + No preparation of the structure is needed + return UNZ_OK if there is no problem. */ + + +extern int ZEXPORT unzGetGlobalComment OF((unzFile file, + char *szComment, + uLong uSizeBuf)); +/* + Get the global comment string of the ZipFile, in the szComment buffer. + uSizeBuf is the size of the szComment buffer. + return the number of byte copied or an error code <0 +*/ + + +/***************************************************************************/ +/* Unzip package allow you browse the directory of the zipfile */ + +extern int ZEXPORT unzGoToFirstFile OF((unzFile file)); +/* + Set the current file of the zipfile to the first file. + return UNZ_OK if there is no problem +*/ + +extern int ZEXPORT unzGoToNextFile OF((unzFile file)); +/* + Set the current file of the zipfile to the next file. + return UNZ_OK if there is no problem + return UNZ_END_OF_LIST_OF_FILE if the actual file was the latest. +*/ + +extern int ZEXPORT unzLocateFile OF((unzFile file, + const char *szFileName, + int iCaseSensitivity)); +/* + Try locate the file szFileName in the zipfile. + For the iCaseSensitivity signification, see unzStringFileNameCompare + + return value : + UNZ_OK if the file is found. It becomes the current file. + UNZ_END_OF_LIST_OF_FILE if the file is not found +*/ + + +/* ****************************************** */ +/* Ryan supplied functions */ +/* unz_file_info contain information about a file in the zipfile */ +typedef struct unz_file_pos_s +{ + uLong pos_in_zip_directory; /* offset in zip file directory */ + uLong num_of_file; /* # of file */ +} unz_file_pos; + +extern int ZEXPORT unzGetFilePos( + unzFile file, + unz_file_pos* file_pos); + +extern int ZEXPORT unzGoToFilePos( + unzFile file, + unz_file_pos* file_pos); + +/* ****************************************** */ + +extern int ZEXPORT unzGetCurrentFileInfo OF((unzFile file, + unz_file_info *pfile_info, + char *szFileName, + uLong fileNameBufferSize, + void *extraField, + uLong extraFieldBufferSize, + char *szComment, + uLong commentBufferSize)); +/* + Get Info about the current file + if pfile_info!=NULL, the *pfile_info structure will contain somes info about + the current file + if szFileName!=NULL, the filemane string will be copied in szFileName + (fileNameBufferSize is the size of the buffer) + if extraField!=NULL, the extra field information will be copied in extraField + (extraFieldBufferSize is the size of the buffer). + This is the Central-header version of the extra field + if szComment!=NULL, the comment string of the file will be copied in szComment + (commentBufferSize is the size of the buffer) +*/ + +/***************************************************************************/ +/* for reading the content of the current zipfile, you can open it, read data + from it, and close it (you can close it before reading all the file) + */ + +extern int ZEXPORT unzOpenCurrentFile OF((unzFile file)); +/* + Open for reading data the current file in the zipfile. + If there is no error, the return value is UNZ_OK. +*/ + +extern int ZEXPORT unzOpenCurrentFilePassword OF((unzFile file, + const char* password)); +/* + Open for reading data the current file in the zipfile. + password is a crypting password + If there is no error, the return value is UNZ_OK. +*/ + +extern int ZEXPORT unzOpenCurrentFile2 OF((unzFile file, + int* method, + int* level, + int raw)); +/* + Same than unzOpenCurrentFile, but open for read raw the file (not uncompress) + if raw==1 + *method will receive method of compression, *level will receive level of + compression + note : you can set level parameter as NULL (if you did not want known level, + but you CANNOT set method parameter as NULL +*/ + +extern int ZEXPORT unzOpenCurrentFile3 OF((unzFile file, + int* method, + int* level, + int raw, + const char* password)); +/* + Same than unzOpenCurrentFile, but open for read raw the file (not uncompress) + if raw==1 + *method will receive method of compression, *level will receive level of + compression + note : you can set level parameter as NULL (if you did not want known level, + but you CANNOT set method parameter as NULL +*/ + + +extern int ZEXPORT unzCloseCurrentFile OF((unzFile file)); +/* + Close the file in zip opened with unzOpenCurrentFile + Return UNZ_CRCERROR if all the file was read but the CRC is not good +*/ + +extern int ZEXPORT unzReadCurrentFile OF((unzFile file, + voidp buf, + unsigned len)); +/* + Read bytes from the current file (opened by unzOpenCurrentFile) + buf contain buffer where data must be copied + len the size of buf. + + return the number of byte copied if somes bytes are copied + return 0 if the end of file was reached + return <0 with error code if there is an error + (UNZ_ERRNO for IO error, or zLib error for uncompress error) +*/ + +extern z_off_t ZEXPORT unztell OF((unzFile file)); +/* + Give the current position in uncompressed data +*/ + +extern int ZEXPORT unzeof OF((unzFile file)); +/* + return 1 if the end of file was reached, 0 elsewhere +*/ + +extern int ZEXPORT unzGetLocalExtrafield OF((unzFile file, + voidp buf, + unsigned len)); +/* + Read extra field from the current file (opened by unzOpenCurrentFile) + This is the local-header version of the extra field (sometimes, there is + more info in the local-header version than in the central-header) + + if buf==NULL, it return the size of the local extra field + + if buf!=NULL, len is the size of the buffer, the extra header is copied in + buf. + the return value is the number of bytes copied in buf, or (if <0) + the error code +*/ + +/***************************************************************************/ + +/* Get the current file offset */ +extern uLong ZEXPORT unzGetOffset (unzFile file); + +/* Set the current file offset */ +extern int ZEXPORT unzSetOffset (unzFile file, uLong pos); + + + +#ifdef __cplusplus +} +#endif + +#endif /* _unz_H */ diff --git a/interface/external/quazip/include/zip.h b/interface/external/quazip/include/zip.h new file mode 100644 index 0000000000..269ec2dace --- /dev/null +++ b/interface/external/quazip/include/zip.h @@ -0,0 +1,245 @@ +/* zip.h -- IO for compress .zip files using zlib + Version 1.01e, February 12th, 2005 + + Copyright (C) 1998-2005 Gilles Vollant + + This unzip package allow creates .ZIP file, compatible with PKZip 2.04g + WinZip, InfoZip tools and compatible. + Multi volume ZipFile (span) are not supported. + Encryption compatible with pkzip 2.04g only supported + Old compressions used by old PKZip 1.x are not supported + + For uncompress .zip file, look at unzip.h + + + I WAIT FEEDBACK at mail info@winimage.com + Visit also http://www.winimage.com/zLibDll/unzip.html for evolution + + Condition of use and distribution are the same than zlib : + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. + + Modified by Sergey A. Tachenov to integrate with Qt. + + +*/ + +/* for more info about .ZIP format, see + http://www.info-zip.org/pub/infozip/doc/appnote-981119-iz.zip + http://www.info-zip.org/pub/infozip/doc/ + PkWare has also a specification at : + ftp://ftp.pkware.com/probdesc.zip +*/ + +#ifndef _zip_H +#define _zip_H + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef _ZLIB_H +#include "zlib.h" +#endif + +#ifndef _ZLIBIOAPI_H +#include "ioapi.h" +#endif + +#if defined(STRICTZIP) || defined(STRICTZIPUNZIP) +/* like the STRICT of WIN32, we define a pointer that cannot be converted + from (void*) without cast */ +typedef struct TagzipFile__ { int unused; } zipFile__; +typedef zipFile__ *zipFile; +#else +typedef voidp zipFile; +#endif + +#define ZIP_OK (0) +#define ZIP_EOF (0) +#define ZIP_ERRNO (Z_ERRNO) +#define ZIP_PARAMERROR (-102) +#define ZIP_BADZIPFILE (-103) +#define ZIP_INTERNALERROR (-104) + +#define ZIP_WRITE_DATA_DESCRIPTOR 0x8u + +#ifndef DEF_MEM_LEVEL +# if MAX_MEM_LEVEL >= 8 +# define DEF_MEM_LEVEL 8 +# else +# define DEF_MEM_LEVEL MAX_MEM_LEVEL +# endif +#endif +/* default memLevel */ + +/* tm_zip contain date/time info */ +typedef struct tm_zip_s +{ + uInt tm_sec; /* seconds after the minute - [0,59] */ + uInt tm_min; /* minutes after the hour - [0,59] */ + uInt tm_hour; /* hours since midnight - [0,23] */ + uInt tm_mday; /* day of the month - [1,31] */ + uInt tm_mon; /* months since January - [0,11] */ + uInt tm_year; /* years - [1980..2044] */ +} tm_zip; + +typedef struct +{ + tm_zip tmz_date; /* date in understandable format */ + uLong dosDate; /* if dos_date == 0, tmu_date is used */ +/* uLong flag; */ /* general purpose bit flag 2 bytes */ + + uLong internal_fa; /* internal file attributes 2 bytes */ + uLong external_fa; /* external file attributes 4 bytes */ +} zip_fileinfo; + +typedef const char* zipcharpc; + + +#define APPEND_STATUS_CREATE (0) +#define APPEND_STATUS_CREATEAFTER (1) +#define APPEND_STATUS_ADDINZIP (2) + +extern zipFile ZEXPORT zipOpen OF((voidpf file, int append)); +/* + Create a zipfile. + file is whatever the IO API accepts. For Qt IO API it's a pointer to + QIODevice. For fopen() IO API it's a file name (const char*). + if the file pathname exist and append==APPEND_STATUS_CREATEAFTER, the zip + will be created at the end of the file. + (useful if the file contain a self extractor code) + if the file pathname exist and append==APPEND_STATUS_ADDINZIP, we will + add files in existing zip (be sure you don't add file that doesn't exist) + If the zipfile cannot be opened, the return value is NULL. + Else, the return value is a zipFile Handle, usable with other function + of this zip package. +*/ + +/* Note : there is no delete function into a zipfile. + If you want delete file into a zipfile, you must open a zipfile, and create another + Of couse, you can use RAW reading and writing to copy the file you did not want delte +*/ + +extern zipFile ZEXPORT zipOpen2 OF((voidpf file, + int append, + zipcharpc* globalcomment, + zlib_filefunc_def* pzlib_filefunc_def)); + +extern int ZEXPORT zipOpenNewFileInZip OF((zipFile file, + const char* filename, + const zip_fileinfo* zipfi, + const void* extrafield_local, + uInt size_extrafield_local, + const void* extrafield_global, + uInt size_extrafield_global, + const char* comment, + int method, + int level)); +/* + Open a file in the ZIP for writing. + filename : the filename in zip (if NULL, '-' without quote will be used + *zipfi contain supplemental information + if extrafield_local!=NULL and size_extrafield_local>0, extrafield_local + contains the extrafield data the the local header + if extrafield_global!=NULL and size_extrafield_global>0, extrafield_global + contains the extrafield data the the local header + if comment != NULL, comment contain the comment string + method contain the compression method (0 for store, Z_DEFLATED for deflate) + level contain the level of compression (can be Z_DEFAULT_COMPRESSION) +*/ + + +extern int ZEXPORT zipOpenNewFileInZip2 OF((zipFile file, + const char* filename, + const zip_fileinfo* zipfi, + const void* extrafield_local, + uInt size_extrafield_local, + const void* extrafield_global, + uInt size_extrafield_global, + const char* comment, + int method, + int level, + int raw)); + +/* + Same than zipOpenNewFileInZip, except if raw=1, we write raw file + */ + +extern int ZEXPORT zipOpenNewFileInZip3 OF((zipFile file, + const char* filename, + const zip_fileinfo* zipfi, + const void* extrafield_local, + uInt size_extrafield_local, + const void* extrafield_global, + uInt size_extrafield_global, + const char* comment, + int method, + int level, + int raw, + int windowBits, + int memLevel, + int strategy, + const char* password, + uLong crcForCtypting)); + +/* + Same than zipOpenNewFileInZip2, except + windowBits,memLevel,,strategy : see parameter strategy in deflateInit2 + password : crypting password (NULL for no crypting) + crcForCtypting : crc of file to compress (needed for crypting) + */ + + +extern int ZEXPORT zipWriteInFileInZip OF((zipFile file, + const void* buf, + unsigned len)); +/* + Write data in the zipfile +*/ + +extern int ZEXPORT zipCloseFileInZip OF((zipFile file)); +/* + Close the current file in the zipfile +*/ + +extern int ZEXPORT zipCloseFileInZipRaw OF((zipFile file, + uLong uncompressed_size, + uLong crc32)); +/* + Close the current file in the zipfile, for fiel opened with + parameter raw=1 in zipOpenNewFileInZip2 + uncompressed_size and crc32 are value for the uncompressed size +*/ + +extern int ZEXPORT zipClose OF((zipFile file, + const char* global_comment)); +/* + Close the zipfile +*/ + +/* + Added by Sergey A. Tachenov to tweak zipping behaviour. + */ +extern int ZEXPORT zipSetFlags(zipFile file, unsigned flags); +extern int ZEXPORT zipClearFlags(zipFile file, unsigned flags); + +#ifdef __cplusplus +} +#endif + +#endif /* _zip_H */ diff --git a/interface/external/quazip/lib/MacOS/libquazip.a b/interface/external/quazip/lib/MacOS/libquazip.a new file mode 100644 index 0000000000..2c7b66f5d1 Binary files /dev/null and b/interface/external/quazip/lib/MacOS/libquazip.a differ diff --git a/interface/resources/info/ApplicationInfo.ini b/interface/resources/info/ApplicationInfo.ini new file mode 100644 index 0000000000..76e481ffce --- /dev/null +++ b/interface/resources/info/ApplicationInfo.ini @@ -0,0 +1,5 @@ +[INFO] +name=interface +version=0.0.1 +organizationName=High Fidelity +organizationDomain=highfidelity.io \ No newline at end of file diff --git a/interface/src/Application.cpp b/interface/src/Application.cpp index df84abe4c7..de6618f831 100755 --- a/interface/src/Application.cpp +++ b/interface/src/Application.cpp @@ -62,6 +62,7 @@ #include "Util.h" #include "renderer/ProgramObject.h" #include "ui/TextRenderer.h" +#include "fvupdater.h" using namespace std; @@ -248,10 +249,28 @@ Application::Application(int& argc, char** argv, timeval &startup_time) : _window->setCentralWidget(_glWidget); - // these are used, for example, to identify the application settings - setApplicationName("Interface"); - setOrganizationDomain("highfidelity.io"); - setOrganizationName("High Fidelity"); +#ifdef Q_WS_MAC + QString resourcesPath = QCoreApplication::applicationDirPath() + "/../Resources"; +#else + QString resourcesPath = QCoreApplication::applicationDirPath() + "/resources"; +#endif + + // read the ApplicationInfo.ini file for Name/Version/Domain information + QSettings applicationInfo(resourcesPath + "/info/ApplicationInfo.ini", QSettings::IniFormat); + + // set the associated application properties + applicationInfo.beginGroup("INFO"); + + setApplicationName(applicationInfo.value("name").toString()); + setApplicationVersion(applicationInfo.value("version").toString()); + setOrganizationName(applicationInfo.value("organizationName").toString()); + setOrganizationDomain(applicationInfo.value("organizationDomain").toString()); + +#if defined(Q_WS_MAC) && defined(QT_NO_DEBUG) + // if this is a release OS X build use fervor to check for an update + FvUpdater::sharedUpdater()->SetFeedURL("https://s3-us-west-1.amazonaws.com/highfidelity/appcast.xml"); + FvUpdater::sharedUpdater()->CheckForUpdatesSilent(); +#endif initMenu(); diff --git a/interface/src/Application.h b/interface/src/Application.h index be95f81c15..e2b0cd21f4 100644 --- a/interface/src/Application.h +++ b/interface/src/Application.h @@ -9,9 +9,9 @@ #ifndef __interface__Application__ #define __interface__Application__ +#include #include #include -#include #include #include diff --git a/interface/src/Avatar.cpp b/interface/src/Avatar.cpp index 78178cca4a..277cca906e 100755 --- a/interface/src/Avatar.cpp +++ b/interface/src/Avatar.cpp @@ -436,7 +436,7 @@ void Avatar::simulate(float deltaTime, Transmitter* transmitter) { glm::vec3 right = orientation * IDENTITY_RIGHT; // Update movement timers - if (!_owningAgent) { + if (isMyAvatar()) { _elapsedTimeSinceCollision += deltaTime; const float VELOCITY_MOVEMENT_TIMER_THRESHOLD = 0.2f; if (glm::length(_velocity) < VELOCITY_MOVEMENT_TIMER_THRESHOLD) { @@ -449,14 +449,14 @@ void Avatar::simulate(float deltaTime, Transmitter* transmitter) { } // Collect thrust forces from keyboard and devices - if (!_owningAgent) { + if (isMyAvatar()) { updateThrust(deltaTime, transmitter); } // copy velocity so we can use it later for acceleration glm::vec3 oldVelocity = getVelocity(); - if (!_owningAgent) { + if (isMyAvatar()) { // update position by velocity _position += _velocity * deltaTime; @@ -465,7 +465,7 @@ void Avatar::simulate(float deltaTime, Transmitter* transmitter) { } //figure out if the mouse cursor is over any body spheres... - if (!_owningAgent) { + if (isMyAvatar()) { checkForMouseRayTouching(); } @@ -508,12 +508,12 @@ void Avatar::simulate(float deltaTime, Transmitter* transmitter) { // if this is not my avatar, then hand position comes from transmitted data - if (_owningAgent) { + if (!isMyAvatar()) { _skeleton.joint[ AVATAR_JOINT_RIGHT_FINGERTIPS ].position = _handPosition; } //detect and respond to collisions with other avatars... - if (!_owningAgent) { + if (isMyAvatar()) { updateAvatarCollisions(deltaTime); } @@ -522,10 +522,10 @@ void Avatar::simulate(float deltaTime, Transmitter* transmitter) { _avatarTouch.simulate(deltaTime); // apply gravity and collision with the ground/floor - if (!_owningAgent && USING_AVATAR_GRAVITY) { + if (isMyAvatar() && USING_AVATAR_GRAVITY) { _velocity += _gravity * (GRAVITY_EARTH * deltaTime); } - if (!_owningAgent) { + if (isMyAvatar()) { updateCollisionWithEnvironment(); } @@ -538,11 +538,11 @@ void Avatar::simulate(float deltaTime, Transmitter* transmitter) { } // collision response with voxels - if (!_owningAgent) { + if (isMyAvatar()) { updateCollisionWithVoxels(); } - if (!_owningAgent) { + if (isMyAvatar()) { // add thrust to velocity _velocity += _thrust * deltaTime; @@ -655,7 +655,7 @@ void Avatar::simulate(float deltaTime, Transmitter* transmitter) { _head.setPosition(_bodyBall[ BODY_BALL_HEAD_BASE ].position); _head.setScale (_bodyBall[ BODY_BALL_HEAD_BASE ].radius); _head.setSkinColor(glm::vec3(SKIN_COLOR[0], SKIN_COLOR[1], SKIN_COLOR[2])); - _head.simulate(deltaTime, !_owningAgent); + _head.simulate(deltaTime, isMyAvatar()); // use speed and angular velocity to determine walking vs. standing if (_speed + fabs(_bodyYawDelta) > 0.2) { @@ -714,7 +714,7 @@ void Avatar::updateHandMovementAndTouching(float deltaTime) { _skeleton.joint[ AVATAR_JOINT_RIGHT_FINGERTIPS ].position += transformedHandMovement; - if (!_owningAgent) { + if (isMyAvatar()) { _avatarTouch.setMyBodyPosition(_position); _avatarTouch.setMyOrientation(orientation); @@ -806,7 +806,7 @@ void Avatar::updateHandMovementAndTouching(float deltaTime) { updateArmIKAndConstraints(deltaTime); //Set right hand position and state to be transmitted, and also tell AvatarTouch about it - if (!_owningAgent) { + if (isMyAvatar()) { setHandPosition(_skeleton.joint[ AVATAR_JOINT_RIGHT_FINGERTIPS ].position); if (_mousePressed) { @@ -990,7 +990,7 @@ void Avatar::setGravity(glm::vec3 gravity) { void Avatar::render(bool lookingInMirror, bool renderAvatarBalls) { - if (!_owningAgent && usingBigSphereCollisionTest) { + if (isMyAvatar() && usingBigSphereCollisionTest) { // show TEST big sphere glColor4f(0.5f, 0.6f, 0.8f, 0.7); glPushMatrix(); @@ -1007,7 +1007,7 @@ void Avatar::render(bool lookingInMirror, bool renderAvatarBalls) { renderBody(lookingInMirror, renderAvatarBalls); // if this is my avatar, then render my interactions with the other avatar - if (!_owningAgent) { + if (isMyAvatar()) { _avatarTouch.render(Application::getInstance()->getCamera()->getPosition()); } @@ -1209,7 +1209,7 @@ float Avatar::getBallRenderAlpha(int ball, bool lookingInMirror) const { const float RENDER_OPAQUE_OUTSIDE = 1.25f; // render opaque if greater than this distance const float DO_NOT_RENDER_INSIDE = 0.75f; // do not render if less than this distance float distanceToCamera = glm::length(Application::getInstance()->getCamera()->getPosition() - _bodyBall[ball].position); - return (lookingInMirror || _owningAgent) ? 1.0f : glm::clamp( + return (lookingInMirror || !isMyAvatar()) ? 1.0f : glm::clamp( (distanceToCamera - DO_NOT_RENDER_INSIDE) / (RENDER_OPAQUE_OUTSIDE - DO_NOT_RENDER_INSIDE), 0.f, 1.f); } @@ -1227,7 +1227,7 @@ void Avatar::renderBody(bool lookingInMirror, bool renderAvatarBalls) { } } else if (alpha > 0.0f) { // Render the body ball sphere - if (_owningAgent || b == BODY_BALL_RIGHT_ELBOW + if (!isMyAvatar() || b == BODY_BALL_RIGHT_ELBOW || b == BODY_BALL_RIGHT_WRIST || b == BODY_BALL_RIGHT_FINGERTIPS ) { glColor3f(SKIN_COLOR[0] + _bodyBall[b].touchForce * 0.3f, diff --git a/interface/src/Avatar.h b/interface/src/Avatar.h index 1cdda74fbe..86c333dad4 100755 --- a/interface/src/Avatar.h +++ b/interface/src/Avatar.h @@ -159,6 +159,8 @@ private: // privatize copy constructor and assignment operator to avoid copying Avatar(const Avatar&); Avatar& operator= (const Avatar&); + + bool isMyAvatar() const { return _owningAgent == NULL; } struct AvatarBall { diff --git a/interface/src/Webcam.cpp b/interface/src/Webcam.cpp index 586e806ce3..1b370f6c4b 100644 --- a/interface/src/Webcam.cpp +++ b/interface/src/Webcam.cpp @@ -186,7 +186,7 @@ FrameGrabber::~FrameGrabber() { } void FrameGrabber::reset() { - _searchWindow = Rect(0, 0, 0, 0); + _searchWindow = cv::Rect(0, 0, 0, 0); } void FrameGrabber::grabFrame() { @@ -235,7 +235,7 @@ void FrameGrabber::grabFrame() { float ranges[] = { 0, 180 }; const float* range = ranges; if (_searchWindow.area() == 0) { - vector faces; + vector faces; _faceCascade.detectMultiScale(frame, faces, 1.1, 6); if (!faces.empty()) { _searchWindow = faces.front();