summaryrefslogtreecommitdiffstats
path: root/utils/rbutilqt/gui/selectiveinstallwidget.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'utils/rbutilqt/gui/selectiveinstallwidget.cpp')
-rw-r--r--utils/rbutilqt/gui/selectiveinstallwidget.cpp691
1 files changed, 691 insertions, 0 deletions
diff --git a/utils/rbutilqt/gui/selectiveinstallwidget.cpp b/utils/rbutilqt/gui/selectiveinstallwidget.cpp
new file mode 100644
index 0000000000..9bfe7414a3
--- /dev/null
+++ b/utils/rbutilqt/gui/selectiveinstallwidget.cpp
@@ -0,0 +1,691 @@
+/***************************************************************************
+ * __________ __ ___.
+ * Open \______ \ ____ ____ | | _\_ |__ _______ ___
+ * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
+ * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
+ * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
+ * \/ \/ \/ \/ \/
+ *
+ * Copyright (C) 2012 by Dominik Riebeling
+ *
+ * All files in this archive are subject to the GNU General Public License.
+ * See the file COPYING in the source tree root for full license agreement.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ****************************************************************************/
+
+#include <QWidget>
+#include <QMessageBox>
+#include <QFileDialog>
+#include "selectiveinstallwidget.h"
+#include "ui_selectiveinstallwidgetfrm.h"
+#include "playerbuildinfo.h"
+#include "rbsettings.h"
+#include "rockboxinfo.h"
+#include "progressloggergui.h"
+#include "bootloaderinstallbase.h"
+#include "bootloaderinstallhelper.h"
+#include "themesinstallwindow.h"
+#include "utils.h"
+#include "Logger.h"
+
+SelectiveInstallWidget::SelectiveInstallWidget(QWidget* parent) : QWidget(parent)
+{
+ ui.setupUi(this);
+ ui.rockboxCheckbox->setChecked(RbSettings::value(RbSettings::InstallRockbox).toBool());
+ ui.fontsCheckbox->setChecked(RbSettings::value(RbSettings::InstallFonts).toBool());
+ ui.themesCheckbox->setChecked(RbSettings::value(RbSettings::InstallThemes).toBool());
+ ui.pluginDataCheckbox->setChecked(RbSettings::value(RbSettings::InstallPluginData).toBool());
+ ui.voiceCheckbox->setChecked(RbSettings::value(RbSettings::InstallVoice).toBool());
+ ui.manualCheckbox->setChecked(RbSettings::value(RbSettings::InstallManual).toBool());
+
+ ui.manualCombobox->addItem("PDF", "pdf");
+ ui.manualCombobox->addItem("HTML (zip)", "zip");
+ ui.manualCombobox->addItem("HTML", "html");
+
+ // check if Rockbox is installed by looking after rockbox-info.txt.
+ // If installed uncheck bootloader installation.
+ RockboxInfo info(m_mountpoint);
+ ui.bootloaderCheckbox->setChecked(!info.success());
+
+ m_logger = nullptr;
+ m_zipinstaller = nullptr;
+ m_themesinstaller = nullptr;
+
+ connect(ui.installButton, &QAbstractButton::clicked,
+ this, &SelectiveInstallWidget::startInstall);
+ connect(this, &SelectiveInstallWidget::installSkipped,
+ this, &SelectiveInstallWidget::continueInstall);
+ connect(ui.themesCustomize, &QAbstractButton::clicked,
+ this, &SelectiveInstallWidget::customizeThemes);
+ connect(ui.selectedVersion, static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged),
+ this, &SelectiveInstallWidget::selectedVersionChanged);
+ // update version information. This also handles setting the previously
+ // selected build type and bootloader disabling.
+ updateVersion();
+}
+
+
+void SelectiveInstallWidget::selectedVersionChanged(int index)
+{
+ m_buildtype = static_cast<PlayerBuildInfo::BuildType>(ui.selectedVersion->itemData(index).toInt());
+ bool voice = true;
+ switch(m_buildtype) {
+ case PlayerBuildInfo::TypeRelease:
+ ui.selectedDescription->setText(tr("This is the latest stable "
+ "release available."));
+ voice = true;
+ break;
+ case PlayerBuildInfo::TypeDevel:
+ ui.selectedDescription->setText(tr("The development version is "
+ "updated on every code change."));
+ voice = false;
+ break;
+ case PlayerBuildInfo::TypeCandidate:
+ ui.selectedDescription->setText(tr("This will eventually become the "
+ "next Rockbox version. Install it to help testing."));
+ voice = false;
+ break;
+ case PlayerBuildInfo::TypeDaily:
+ ui.selectedDescription->setText(tr("Daily updated development version."));
+ voice = true;
+ break;
+ }
+ ui.voiceCheckbox->setEnabled(voice);
+ ui.voiceCombobox->setEnabled(voice);
+ ui.voiceLabel->setEnabled(voice);
+ ui.voiceCheckbox->setToolTip(voice ? "" : tr("Not available for the selected version"));
+
+ updateVoiceLangs();
+}
+
+
+void SelectiveInstallWidget::updateVersion(void)
+{
+ // get some configuration values globally
+ m_mountpoint = RbSettings::value(RbSettings::Mountpoint).toString();
+ m_target = RbSettings::value(RbSettings::CurrentPlatform).toString();
+ m_blmethod = PlayerBuildInfo::instance()->value(
+ PlayerBuildInfo::BootloaderMethod, m_target).toString();
+
+ if(m_logger != nullptr) {
+ delete m_logger;
+ m_logger = nullptr;
+ }
+
+ // re-populate all version items
+ QMap<PlayerBuildInfo::BuildType, QString> types;
+ types[PlayerBuildInfo::TypeRelease] = tr("Stable Release (Version %1)");
+ if (PlayerBuildInfo::instance()->value(PlayerBuildInfo::BuildStatus).toInt() != STATUS_RETIRED) {
+ types[PlayerBuildInfo::TypeCandidate] = tr("Release Candidate (Revison %1)");
+ types[PlayerBuildInfo::TypeDaily] = tr("Daily Build (%1)");
+ types[PlayerBuildInfo::TypeDevel] = tr("Development Version (Revison %1)");
+ }
+
+ ui.selectedVersion->clear();
+ for(auto i = types.begin(); i != types.end(); i++) {
+ QString version = PlayerBuildInfo::instance()->value(
+ PlayerBuildInfo::BuildVersion, i.key()).toString();
+ if(!version.isEmpty())
+ ui.selectedVersion->addItem(i.value().arg(version), i.key());
+ }
+
+ // select previously selected version
+ int index = ui.selectedVersion->findData(
+ static_cast<PlayerBuildInfo::BuildType>(RbSettings::value(RbSettings::Build).toInt()));
+ if(index < 0) {
+ index = ui.selectedVersion->findData(PlayerBuildInfo::TypeRelease);
+ if(index < 0) {
+ index = ui.selectedVersion->findData(PlayerBuildInfo::TypeDevel);
+ }
+ }
+ ui.selectedVersion->setCurrentIndex(index);
+ // check if Rockbox is installed. If it is untick the bootloader option, as
+ // well as if the selected player doesn't need a bootloader.
+ if(m_blmethod == "none") {
+ ui.bootloaderCheckbox->setEnabled(false);
+ ui.bootloaderCheckbox->setChecked(false);
+ ui.bootloaderLabel->setEnabled(false);
+ ui.bootloaderLabel->setText(tr("The selected player doesn't need a bootloader."));
+ }
+ else {
+ ui.bootloaderCheckbox->setEnabled(true);
+ ui.bootloaderLabel->setEnabled(true);
+ ui.bootloaderLabel->setText(tr("The bootloader is required for starting "
+ "Rockbox. Installation of the bootloader is only necessary "
+ "on first time installation."));
+ // check if Rockbox is installed by looking after rockbox-info.txt.
+ // If installed uncheck bootloader installation.
+ RockboxInfo info(m_mountpoint);
+ ui.bootloaderCheckbox->setChecked(!info.success());
+ }
+
+ updateVoiceLangs();
+}
+
+void SelectiveInstallWidget::updateVoiceLangs()
+{
+ // populate languages for voice file.
+ QVariant current = ui.voiceCombobox->currentData();
+ QMap<QString, QVariant> langs = PlayerBuildInfo::instance()->value(
+ PlayerBuildInfo::LanguageList).toMap();
+ QStringList voicelangs = PlayerBuildInfo::instance()->value(
+ PlayerBuildInfo::BuildVoiceLangs, m_buildtype).toStringList();
+ ui.voiceCombobox->clear();
+ for(auto it = langs.begin(); it != langs.end(); it++) {
+ if(voicelangs.contains(it.key())) {
+ ui.voiceCombobox->addItem(it.value().toString(), it.key());
+ LOG_INFO() << "available voices: adding" << it.key();
+ }
+
+ }
+ // try to select the previously selected one again (if still present)
+ // TODO: Fall back to system language if not found, or english.
+ int sel = ui.voiceCombobox->findData(current);
+ if(sel >= 0)
+ ui.voiceCombobox->setCurrentIndex(sel);
+
+}
+
+
+void SelectiveInstallWidget::saveSettings(void)
+{
+ LOG_INFO() << "saving current settings";
+
+ RbSettings::setValue(RbSettings::InstallRockbox, ui.rockboxCheckbox->isChecked());
+ RbSettings::setValue(RbSettings::InstallFonts, ui.fontsCheckbox->isChecked());
+ RbSettings::setValue(RbSettings::InstallThemes, ui.themesCheckbox->isChecked());
+ RbSettings::setValue(RbSettings::InstallPluginData, ui.pluginDataCheckbox->isChecked());
+ RbSettings::setValue(RbSettings::InstallVoice, ui.voiceCheckbox->isChecked());
+ RbSettings::setValue(RbSettings::InstallManual, ui.manualCheckbox->isChecked());
+ RbSettings::setValue(RbSettings::VoiceLanguage, ui.voiceCombobox->currentData().toString());
+}
+
+
+void SelectiveInstallWidget::startInstall(void)
+{
+ LOG_INFO() << "starting installation";
+ saveSettings();
+
+ m_installStage = 0;
+ if(m_logger != nullptr) delete m_logger;
+ m_logger = new ProgressLoggerGui(this);
+ QString warning = Utils::checkEnvironment(false);
+ if(!warning.isEmpty())
+ {
+ warning += "<br/>" + tr("Continue with installation?");
+ if(QMessageBox::warning(this, tr("Really continue?"), warning,
+ QMessageBox::Ok | QMessageBox::Abort, QMessageBox::Abort)
+ == QMessageBox::Abort)
+ {
+ emit installSkipped(true);
+ return;
+ }
+ }
+
+ m_logger->show();
+ if(!QFileInfo(m_mountpoint).isDir()) {
+ m_logger->addItem(tr("Mountpoint is wrong"), LOGERROR);
+ m_logger->setFinished();
+ return;
+ }
+ // start installation. No errors until now.
+ continueInstall(false);
+
+}
+
+
+void SelectiveInstallWidget::continueInstall(bool error)
+{
+ LOG_INFO() << "continuing install with stage" << m_installStage;
+ if(error) {
+ LOG_ERROR() << "Last part returned error.";
+ m_logger->setFinished();
+ m_installStage = 9;
+ }
+ m_installStage++;
+ switch(m_installStage) {
+ case 0: LOG_ERROR() << "Something wrong!"; break;
+ case 1: installBootloader(); break;
+ case 2: installRockbox(); break;
+ case 3: installFonts(); break;
+ case 4: installThemes(); break;
+ case 5: installPluginData(); break;
+ case 6: installVoicefile(); break;
+ case 7: installManual(); break;
+ case 8: installBootloaderPost(); break;
+ default: break;
+ }
+
+ if(m_installStage > 8) {
+ LOG_INFO() << "All install stages done.";
+ m_logger->setFinished();
+ if(m_blmethod != "none") {
+ // check if Rockbox is installed by looking after rockbox-info.txt.
+ // If installed uncheck bootloader installation.
+ RockboxInfo info(m_mountpoint);
+ ui.bootloaderCheckbox->setChecked(!info.success());
+ }
+ }
+}
+
+
+void SelectiveInstallWidget::installBootloader(void)
+{
+ if(ui.bootloaderCheckbox->isChecked()) {
+ LOG_INFO() << "installing bootloader";
+
+ QString platform = RbSettings::value(RbSettings::Platform).toString();
+ QString backupDestination = "";
+
+ // create installer
+ BootloaderInstallBase *bl =
+ BootloaderInstallHelper::createBootloaderInstaller(this,
+ PlayerBuildInfo::instance()->value(
+ PlayerBuildInfo::BootloaderMethod).toString());
+ if(bl == nullptr) {
+ m_logger->addItem(tr("No install method known."), LOGERROR);
+ m_logger->setFinished();
+ return;
+ }
+
+ // the bootloader install class does NOT use any GUI stuff.
+ // All messages are passed via signals.
+ connect(bl, SIGNAL(done(bool)), m_logger, SLOT(setFinished()));
+ connect(bl, SIGNAL(done(bool)), this, SLOT(continueInstall(bool)));
+ connect(bl, SIGNAL(logItem(QString, int)), m_logger, SLOT(addItem(QString, int)));
+ connect(bl, SIGNAL(logProgress(int, int)), m_logger, SLOT(setProgress(int, int)));
+ // pass Abort button click signal to current installer
+ connect(m_logger, SIGNAL(aborted()), bl, SLOT(progressAborted()));
+
+ // set bootloader filename. Do this now as installed() needs it.
+ QStringList blfile = PlayerBuildInfo::instance()->value(
+ PlayerBuildInfo::BootloaderFile).toStringList();
+ QStringList blfilepath;
+ for(int a = 0; a < blfile.size(); a++) {
+ blfilepath.append(RbSettings::value(RbSettings::Mountpoint).toString()
+ + blfile.at(a));
+ }
+ bl->setBlFile(blfilepath);
+ QUrl url(PlayerBuildInfo::instance()->value(PlayerBuildInfo::BootloaderUrl).toString()
+ + PlayerBuildInfo::instance()->value(PlayerBuildInfo::BootloaderName).toString());
+ bl->setBlUrl(url);
+ bl->setLogfile(RbSettings::value(RbSettings::Mountpoint).toString()
+ + "/.rockbox/rbutil.log");
+
+ if(bl->installed() == BootloaderInstallBase::BootloaderRockbox) {
+ if(QMessageBox::question(this, tr("Bootloader detected"),
+ tr("Bootloader already installed. Do you want to reinstall the bootloader?"),
+ QMessageBox::Yes | QMessageBox::No) == QMessageBox::No) {
+ // keep m_logger open for auto installs.
+ // don't consider abort as error in auto-mode.
+ m_logger->addItem(tr("Bootloader installation skipped"), LOGINFO);
+ delete bl;
+ emit installSkipped(true);
+ return;
+ }
+ }
+ else if(bl->installed() == BootloaderInstallBase::BootloaderOther
+ && bl->capabilities() & BootloaderInstallBase::Backup)
+ {
+ QString targetFolder = PlayerBuildInfo::instance()->value(
+ PlayerBuildInfo::DisplayName).toString()
+ + " Firmware Backup";
+ // remove invalid character(s)
+ targetFolder.remove(QRegExp("[:/]"));
+ if(QMessageBox::question(this, tr("Create Bootloader backup"),
+ tr("You can create a backup of the original bootloader "
+ "file. Press \"Yes\" to select an output folder on your "
+ "computer to save the file to. The file will get placed "
+ "in a new folder \"%1\" created below the selected folder.\n"
+ "Press \"No\" to skip this step.").arg(targetFolder),
+ QMessageBox::Yes | QMessageBox::No) == QMessageBox::Yes) {
+ backupDestination = QFileDialog::getExistingDirectory(this,
+ tr("Browse backup folder"), QDir::homePath());
+ if(!backupDestination.isEmpty())
+ backupDestination += "/" + targetFolder;
+
+ LOG_INFO() << "backing up to" << backupDestination;
+ // backup needs to be done after the m_logger has been set up.
+ }
+ }
+
+ if(bl->capabilities() & BootloaderInstallBase::NeedsOf)
+ {
+ int ret;
+ ret = QMessageBox::information(this, tr("Prerequisites"),
+ bl->ofHint(),QMessageBox::Ok | QMessageBox::Abort);
+ if(ret != QMessageBox::Ok) {
+ // consider aborting an error to close window / abort automatic
+ // installation.
+ m_logger->addItem(tr("Bootloader installation aborted"), LOGINFO);
+ m_logger->setFinished();
+ emit installSkipped(true);
+ return;
+ }
+ // open dialog to browse to of file
+ QString offile;
+ QString filter
+ = PlayerBuildInfo::instance()->value(PlayerBuildInfo::BootloaderFilter).toString();
+ if(!filter.isEmpty()) {
+ filter = tr("Bootloader files (%1)").arg(filter) + ";;";
+ }
+ filter += tr("All files (*)");
+ offile = QFileDialog::getOpenFileName(this,
+ tr("Select firmware file"), QDir::homePath(), filter);
+ if(!QFileInfo(offile).isReadable()) {
+ m_logger->addItem(tr("Error opening firmware file"), LOGERROR);
+ m_logger->setFinished();
+ emit installSkipped(true);
+ return;
+ }
+ if(!bl->setOfFile(offile, blfile)) {
+ m_logger->addItem(tr("Error reading firmware file"), LOGERROR);
+ m_logger->setFinished();
+ emit installSkipped(true);
+ return;
+ }
+ }
+
+ // start install.
+ if(!backupDestination.isEmpty()) {
+ if(!bl->backup(backupDestination)) {
+ if(QMessageBox::warning(this, tr("Backup error"),
+ tr("Could not create backup file. Continue?"),
+ QMessageBox::No | QMessageBox::Yes)
+ == QMessageBox::No) {
+ m_logger->setFinished();
+ return;
+ }
+ }
+ }
+ bl->install();
+
+ }
+ else {
+ LOG_INFO() << "Bootloader install disabled.";
+ emit installSkipped(false);
+ }
+}
+
+void SelectiveInstallWidget::installBootloaderPost()
+{
+ // don't do anything if no bootloader install has been done.
+ if(ui.bootloaderCheckbox->isChecked()) {
+ QString msg = BootloaderInstallHelper::postinstallHints(
+ RbSettings::value(RbSettings::Platform).toString());
+ if(!msg.isEmpty()) {
+ QMessageBox::information(this, tr("Manual steps required"), msg);
+ }
+ }
+ emit installSkipped(false);
+}
+
+
+void SelectiveInstallWidget::installRockbox(void)
+{
+ if(ui.rockboxCheckbox->isChecked()) {
+ LOG_INFO() << "installing Rockbox";
+ QString url;
+
+ RbSettings::setValue(RbSettings::Build, m_buildtype);
+ RbSettings::sync();
+
+ url = PlayerBuildInfo::instance()->value(
+ PlayerBuildInfo::BuildUrl, m_buildtype).toString();
+ //! install build
+ if(m_zipinstaller != nullptr) m_zipinstaller->deleteLater();
+ m_zipinstaller = new ZipInstaller(this);
+ m_zipinstaller->setUrl(url);
+ m_zipinstaller->setLogSection("Rockbox (Base)");
+ if(!RbSettings::value(RbSettings::CacheDisabled).toBool())
+ m_zipinstaller->setCache(true);
+ m_zipinstaller->setLogVersion(PlayerBuildInfo::instance()->value(
+ PlayerBuildInfo::BuildVersion, m_buildtype).toString());
+ m_zipinstaller->setMountPoint(m_mountpoint);
+
+ connect(m_zipinstaller, SIGNAL(done(bool)), this, SLOT(continueInstall(bool)));
+
+ connect(m_zipinstaller, SIGNAL(logItem(QString, int)), m_logger, SLOT(addItem(QString, int)));
+ connect(m_zipinstaller, SIGNAL(logProgress(int, int)), m_logger, SLOT(setProgress(int, int)));
+ connect(m_logger, SIGNAL(aborted()), m_zipinstaller, SLOT(abort()));
+ m_zipinstaller->install();
+
+ }
+ else {
+ LOG_INFO() << "Rockbox install disabled.";
+ emit installSkipped(false);
+ }
+}
+
+
+void SelectiveInstallWidget::installFonts(void)
+{
+ if(ui.fontsCheckbox->isChecked()) {
+ LOG_INFO() << "installing Fonts";
+
+ RockboxInfo installInfo(m_mountpoint);
+ QString fontsurl;
+ QString logversion;
+ QString relversion = installInfo.release();
+ if(!relversion.isEmpty()) {
+ // release is empty for non-release versions (i.e. daily / current)
+ logversion = installInfo.release();
+ }
+ fontsurl = PlayerBuildInfo::instance()->value(
+ PlayerBuildInfo::BuildFontUrl, m_buildtype).toString();
+ fontsurl.replace("%RELVERSION%", relversion);
+
+ // create new zip installer
+ if(m_zipinstaller != nullptr) m_zipinstaller->deleteLater();
+ m_zipinstaller = new ZipInstaller(this);
+ m_zipinstaller->setUrl(fontsurl);
+ m_zipinstaller->setLogSection("Fonts");
+ m_zipinstaller->setLogVersion(logversion);
+ m_zipinstaller->setMountPoint(m_mountpoint);
+ if(!RbSettings::value(RbSettings::CacheDisabled).toBool())
+ m_zipinstaller->setCache(true);
+
+ connect(m_zipinstaller, SIGNAL(done(bool)), this, SLOT(continueInstall(bool)));
+ connect(m_zipinstaller, SIGNAL(logItem(QString, int)), m_logger, SLOT(addItem(QString, int)));
+ connect(m_zipinstaller, SIGNAL(logProgress(int, int)), m_logger, SLOT(setProgress(int, int)));
+ connect(m_logger, SIGNAL(aborted()), m_zipinstaller, SLOT(abort()));
+ m_zipinstaller->install();
+ }
+ else {
+ LOG_INFO() << "Fonts install disabled.";
+ emit installSkipped(false);
+ }
+}
+
+void SelectiveInstallWidget::installVoicefile(void)
+{
+ if(ui.voiceCheckbox->isChecked() && ui.voiceCheckbox->isEnabled()) {
+ LOG_INFO() << "installing Voice file";
+ QString lang = ui.voiceCombobox->currentData().toString();
+
+ RockboxInfo installInfo(m_mountpoint);
+ QString voiceurl;
+ QString logversion;
+ QString relversion = installInfo.release();
+ if(m_buildtype != PlayerBuildInfo::TypeRelease) {
+ // release is empty for non-release versions (i.e. daily / current)
+ logversion = installInfo.release();
+ }
+ voiceurl = PlayerBuildInfo::instance()->value(
+ PlayerBuildInfo::BuildVoiceUrl, m_buildtype).toString();
+ voiceurl.replace("%LANGUAGE%", lang);
+
+ // create new zip installer
+ if(m_zipinstaller != nullptr) m_zipinstaller->deleteLater();
+ m_zipinstaller = new ZipInstaller(this);
+ m_zipinstaller->setUrl(voiceurl);
+ m_zipinstaller->setLogSection("Prerendered Voice (" + lang + ")");
+ m_zipinstaller->setLogVersion(logversion);
+ m_zipinstaller->setMountPoint(m_mountpoint);
+ if(!RbSettings::value(RbSettings::CacheDisabled).toBool())
+ m_zipinstaller->setCache(true);
+
+ connect(m_zipinstaller, SIGNAL(done(bool)), this, SLOT(continueInstall(bool)));
+ connect(m_zipinstaller, SIGNAL(logItem(QString, int)), m_logger, SLOT(addItem(QString, int)));
+ connect(m_zipinstaller, SIGNAL(logProgress(int, int)), m_logger, SLOT(setProgress(int, int)));
+ connect(m_logger, SIGNAL(aborted()), m_zipinstaller, SLOT(abort()));
+ m_zipinstaller->install();
+ }
+ else {
+ LOG_INFO() << "Voice install disabled.";
+ emit installSkipped(false);
+ }
+}
+
+void SelectiveInstallWidget::installManual(void)
+{
+ if(ui.manualCheckbox->isChecked() && ui.manualCheckbox->isEnabled()) {
+ LOG_INFO() << "installing Manual";
+ QString mantype = ui.manualCombobox->currentData().toString();
+
+ RockboxInfo installInfo(m_mountpoint);
+ QString manualurl;
+ QString logversion;
+ QString relversion = installInfo.release();
+ if(m_buildtype != PlayerBuildInfo::TypeRelease) {
+ // release is empty for non-release versions (i.e. daily / current)
+ logversion = installInfo.release();
+ }
+
+ manualurl = PlayerBuildInfo::instance()->value(
+ PlayerBuildInfo::BuildManualUrl, m_buildtype).toString();
+ if(mantype == "pdf")
+ manualurl.replace("%FORMAT%", ".pdf");
+ else
+ manualurl.replace("%FORMAT%", "-html.zip");
+
+ // create new zip installer
+ if(m_zipinstaller != nullptr) m_zipinstaller->deleteLater();
+ m_zipinstaller = new ZipInstaller(this);
+ m_zipinstaller->setUrl(manualurl);
+ m_zipinstaller->setLogSection("Manual (" + mantype + ")");
+ m_zipinstaller->setLogVersion(logversion);
+ m_zipinstaller->setMountPoint(m_mountpoint);
+ if(!RbSettings::value(RbSettings::CacheDisabled).toBool())
+ m_zipinstaller->setCache(true);
+ // if type is html extract it.
+ m_zipinstaller->setUnzip(mantype == "html");
+
+ connect(m_zipinstaller, SIGNAL(done(bool)), this, SLOT(continueInstall(bool)));
+ connect(m_zipinstaller, SIGNAL(logItem(QString, int)), m_logger, SLOT(addItem(QString, int)));
+ connect(m_zipinstaller, SIGNAL(logProgress(int, int)), m_logger, SLOT(setProgress(int, int)));
+ connect(m_logger, SIGNAL(aborted()), m_zipinstaller, SLOT(abort()));
+ m_zipinstaller->install();
+ }
+ else {
+ LOG_INFO() << "Manual install disabled.";
+ emit installSkipped(false);
+ }
+}
+
+void SelectiveInstallWidget::customizeThemes(void)
+{
+ if(m_themesinstaller == nullptr)
+ m_themesinstaller = new ThemesInstallWindow(this);
+
+ m_themesinstaller->setSelectOnly(true);
+ m_themesinstaller->show();
+}
+
+
+void SelectiveInstallWidget::installThemes(void)
+{
+ if(ui.themesCheckbox->isChecked()) {
+ LOG_INFO() << "installing themes";
+ if(m_themesinstaller == nullptr)
+ m_themesinstaller = new ThemesInstallWindow(this);
+
+ connect(m_themesinstaller, SIGNAL(done(bool)), this, SLOT(continueInstall(bool)));
+ m_themesinstaller->setLogger(m_logger);
+ m_themesinstaller->setModal(true);
+ m_themesinstaller->install();
+ }
+ else {
+ LOG_INFO() << "Themes install disabled.";
+ emit installSkipped(false);
+ }
+}
+
+static const struct {
+ const char *name; // display name
+ const char *rockfile; // rock file to look for
+ PlayerBuildInfo::BuildInfo zipurl; // download url
+} PluginDataFiles[] = {
+ { "Doom", "games/doom.rock", PlayerBuildInfo::DoomUrl },
+ { "Duke3D", "games/duke3d.rock", PlayerBuildInfo::Duke3DUrl },
+ { "Quake", "games/quake.rock", PlayerBuildInfo::QuakeUrl },
+ { "Puzzles fonts", "games/sgt-blackbox.rock", PlayerBuildInfo::PuzzFontsUrl },
+ { "Wolf3D", "games/wolf3d.rock", PlayerBuildInfo::Wolf3DUrl },
+ { "XWorld", "games/xworld.rock", PlayerBuildInfo::XWorldUrl },
+ { "MIDI Patchset", "viewers/midi.rock", PlayerBuildInfo::MidiPatchsetUrl },
+};
+
+void SelectiveInstallWidget::installPluginData(void)
+{
+ if(ui.pluginDataCheckbox->isChecked()) {
+ // build a list of zip urls that we need, then install
+ QStringList dataUrls;
+ QStringList dataName;
+
+ for(size_t i = 0; i < sizeof(PluginDataFiles) / sizeof(PluginDataFiles[0]); i++)
+ {
+ // check if installed Rockbox has this plugin.
+ if(QFileInfo(m_mountpoint + "/.rockbox/rocks/" + PluginDataFiles[i].rockfile).exists()) {
+ dataName.append(PluginDataFiles[i].name);
+ // game URLs do not depend on the actual build type, but we need
+ // to pass it (simplifies the API, and will allow to make them
+ // type specific later if needed)
+ dataUrls.append(PlayerBuildInfo::instance()->value(
+ PluginDataFiles[i].zipurl, m_buildtype).toString());
+ }
+ }
+
+ if(dataUrls.size() == 0)
+ {
+ m_logger->addItem(
+ tr("Your installation doesn't require any plugin data files, skipping."),
+ LOGINFO);
+ emit installSkipped(false);
+ return;
+ }
+
+ LOG_INFO() << "installing plugin data files";
+
+ // create new zip installer
+ if(m_zipinstaller != nullptr) m_zipinstaller->deleteLater();
+ m_zipinstaller = new ZipInstaller(this);
+
+ m_zipinstaller->setUrl(dataUrls);
+ m_zipinstaller->setLogSection(dataName);
+ m_zipinstaller->setLogVersion();
+ m_zipinstaller->setMountPoint(m_mountpoint);
+ if(!RbSettings::value(RbSettings::CacheDisabled).toBool())
+ m_zipinstaller->setCache(true);
+ connect(m_zipinstaller, SIGNAL(done(bool)), this, SLOT(continueInstall(bool)));
+ connect(m_zipinstaller, SIGNAL(logItem(QString, int)), m_logger, SLOT(addItem(QString, int)));
+ connect(m_zipinstaller, SIGNAL(logProgress(int, int)), m_logger, SLOT(setProgress(int, int)));
+ connect(m_logger, SIGNAL(aborted()), m_zipinstaller, SLOT(abort()));
+ m_zipinstaller->install();
+ }
+ else {
+ LOG_INFO() << "Gamefile install disabled.";
+ emit installSkipped(false);
+ }
+}
+
+void SelectiveInstallWidget::changeEvent(QEvent *e)
+{
+ if(e->type() == QEvent::LanguageChange) {
+ ui.retranslateUi(this);
+ } else {
+ QWidget::changeEvent(e);
+ }
+}