2011-04-06 13:48:02 +04:00
|
|
|
/*
|
|
|
|
* Copyright (C) by Duncan Mac-Vicar P. <duncan@kde.org>
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation; either version 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 General Public License
|
|
|
|
* for more details.
|
|
|
|
*/
|
|
|
|
|
2012-06-05 17:11:29 +04:00
|
|
|
#define LOG_TO_CALLBACK // FIXME: This should be in csync.
|
2012-06-15 15:36:38 +04:00
|
|
|
#include <iostream>
|
2012-06-05 17:11:29 +04:00
|
|
|
|
2011-02-17 02:21:45 +03:00
|
|
|
#include "mirall/application.h"
|
|
|
|
#include "mirall/folder.h"
|
2011-09-30 13:49:19 +04:00
|
|
|
#include "mirall/folderwatcher.h"
|
2011-04-05 20:31:14 +04:00
|
|
|
#include "mirall/folderwizard.h"
|
2011-04-06 17:22:40 +04:00
|
|
|
#include "mirall/networklocation.h"
|
2011-03-23 01:03:43 +03:00
|
|
|
#include "mirall/unisonfolder.h"
|
2012-02-15 17:44:09 +04:00
|
|
|
#include "mirall/owncloudfolder.h"
|
2011-09-26 17:00:12 +04:00
|
|
|
#include "mirall/statusdialog.h"
|
2012-02-17 14:11:18 +04:00
|
|
|
#include "mirall/owncloudsetupwizard.h"
|
2012-03-29 11:41:30 +04:00
|
|
|
#include "mirall/owncloudinfo.h"
|
2012-02-16 13:42:44 +04:00
|
|
|
#include "mirall/theme.h"
|
2012-02-17 14:11:18 +04:00
|
|
|
#include "mirall/mirallconfigfile.h"
|
2012-04-02 22:10:29 +04:00
|
|
|
#include "mirall/updatedetector.h"
|
2012-07-31 12:17:52 +04:00
|
|
|
#include "mirall/proxydialog.h"
|
2012-02-16 13:42:44 +04:00
|
|
|
|
|
|
|
#include "mirall/miralltheme.h"
|
|
|
|
#include "mirall/owncloudtheme.h"
|
2011-09-26 15:12:00 +04:00
|
|
|
|
2012-07-20 19:13:23 +04:00
|
|
|
#include "config.h"
|
|
|
|
|
2011-04-07 21:04:07 +04:00
|
|
|
#ifdef WITH_CSYNC
|
|
|
|
#include "mirall/csyncfolder.h"
|
|
|
|
#endif
|
2011-03-16 16:50:34 +03:00
|
|
|
#include "mirall/inotify.h"
|
2011-02-17 02:21:45 +03:00
|
|
|
|
2012-06-05 17:11:29 +04:00
|
|
|
#include <csync.h>
|
|
|
|
|
2012-05-21 18:48:49 +04:00
|
|
|
#include <QtCore>
|
|
|
|
#include <QtGui>
|
|
|
|
#include <QHash>
|
|
|
|
#include <QHashIterator>
|
|
|
|
#include <QUrl>
|
|
|
|
#include <QDesktopServices>
|
|
|
|
#include <QTranslator>
|
2012-07-31 12:17:52 +04:00
|
|
|
#include <QNetworkProxy>
|
|
|
|
#include <QNetworkProxyFactory>
|
2012-05-21 18:48:49 +04:00
|
|
|
|
2011-02-17 02:21:45 +03:00
|
|
|
namespace Mirall {
|
|
|
|
|
2012-06-05 17:11:29 +04:00
|
|
|
// application logging handler.
|
|
|
|
void mirallLogCatcher(QtMsgType type, const char *msg)
|
|
|
|
{
|
|
|
|
Q_UNUSED(type)
|
|
|
|
Logger::instance()->mirallLog( msg );
|
|
|
|
}
|
|
|
|
|
|
|
|
void csyncLogCatcher(const char *msg)
|
|
|
|
{
|
2012-06-05 18:30:55 +04:00
|
|
|
Logger::instance()->csyncLog( QString::fromUtf8(msg) );
|
2012-06-05 17:11:29 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
// ----------------------------------------------------------------------------------
|
|
|
|
|
2012-04-20 15:17:48 +04:00
|
|
|
Application::Application(int &argc, char **argv) :
|
2012-07-30 18:10:48 +04:00
|
|
|
SharedTools::QtSingleApplication(argc, argv),
|
2012-03-31 13:31:28 +04:00
|
|
|
_tray(0),
|
2012-04-21 23:03:29 +04:00
|
|
|
#if QT_VERSION >= 0x040700
|
2011-04-04 14:23:30 +04:00
|
|
|
_networkMgr(new QNetworkConfigurationManager(this)),
|
2012-04-21 23:03:29 +04:00
|
|
|
#endif
|
2012-03-29 11:41:30 +04:00
|
|
|
_contextMenu(0),
|
2012-06-15 15:36:38 +04:00
|
|
|
_updateDetector(0),
|
|
|
|
_helpOnly(false)
|
2011-02-17 02:21:45 +03:00
|
|
|
{
|
2012-03-31 13:31:28 +04:00
|
|
|
|
2012-02-16 13:42:44 +04:00
|
|
|
#ifdef OWNCLOUD_CLIENT
|
|
|
|
_theme = new ownCloudTheme();
|
|
|
|
#else
|
|
|
|
_theme = new mirallTheme();
|
|
|
|
#endif
|
2012-02-17 15:16:48 +04:00
|
|
|
setApplicationName( _theme->appName() );
|
2012-03-31 13:31:28 +04:00
|
|
|
setWindowIcon( _theme->applicationIcon() );
|
2012-02-23 14:44:44 +04:00
|
|
|
|
2012-06-15 15:36:38 +04:00
|
|
|
if( arguments().contains("--help")) {
|
|
|
|
showHelp();
|
|
|
|
}
|
2012-06-05 17:49:53 +04:00
|
|
|
setupLogBrowser();
|
2012-06-15 15:36:38 +04:00
|
|
|
processEvents();
|
2012-04-18 14:10:14 +04:00
|
|
|
|
2012-07-26 12:16:18 +04:00
|
|
|
QTranslator *qtTranslator = new QTranslator(this);
|
2012-04-18 15:59:03 +04:00
|
|
|
qtTranslator->load("qt_" + QLocale::system().name(),
|
2012-03-26 13:02:01 +04:00
|
|
|
QLibraryInfo::location(QLibraryInfo::TranslationsPath));
|
2012-04-18 15:59:03 +04:00
|
|
|
installTranslator(qtTranslator);
|
2012-03-26 13:02:01 +04:00
|
|
|
|
2012-07-26 12:16:18 +04:00
|
|
|
QTranslator *mirallTranslator = new QTranslator(this);
|
2012-04-18 15:59:03 +04:00
|
|
|
#ifdef Q_OS_LINUX
|
|
|
|
// FIXME - proper path!
|
|
|
|
mirallTranslator->load("mirall_" + QLocale::system().name(), QLatin1String("/usr/share/mirall/i18n/"));
|
2012-06-18 17:50:17 +04:00
|
|
|
#endif
|
|
|
|
#ifdef Q_OS_MAC
|
2012-06-18 17:52:56 +04:00
|
|
|
mirallTranslator->load("mirall_" + QLocale::system().name(), applicationDirPath()+QLatin1String("/../translations") ); // path defaults to app dir.
|
2012-06-18 17:50:17 +04:00
|
|
|
#endif
|
2012-06-18 19:45:04 +04:00
|
|
|
#ifdef Q_OS_WIN32
|
2012-04-18 15:59:03 +04:00
|
|
|
mirallTranslator->load("mirall_" + QLocale::system().name()); // path defaults to app dir.
|
|
|
|
#endif
|
2012-06-18 17:50:17 +04:00
|
|
|
|
2012-04-18 15:59:03 +04:00
|
|
|
installTranslator(mirallTranslator);
|
2012-03-26 13:02:01 +04:00
|
|
|
|
2012-04-18 15:59:03 +04:00
|
|
|
// create folder manager for sync folder management
|
2012-08-02 13:08:27 +04:00
|
|
|
_folderMan = new FolderMan(this);
|
2012-02-19 00:21:58 +04:00
|
|
|
connect( _folderMan, SIGNAL(folderSyncStateChange(QString)),
|
|
|
|
this,SLOT(slotSyncStateChange(QString)));
|
|
|
|
|
2012-02-21 14:50:19 +04:00
|
|
|
/* use a signal mapper to map the open requests to the alias names */
|
|
|
|
_folderOpenActionMapper = new QSignalMapper(this);
|
|
|
|
connect(_folderOpenActionMapper, SIGNAL(mapped(const QString &)),
|
|
|
|
this, SLOT(slotFolderOpenAction(const QString &)));
|
|
|
|
|
2011-04-05 20:31:14 +04:00
|
|
|
setQuitOnLastWindowClosed(false);
|
|
|
|
|
2012-03-26 17:19:40 +04:00
|
|
|
_folderWizard = new FolderWizard( 0, _theme );
|
2012-03-30 15:57:02 +04:00
|
|
|
|
2012-07-26 12:16:18 +04:00
|
|
|
connect( ownCloudInfo::instance(),SIGNAL(ownCloudInfoFound(QString,QString,QString,QString)),
|
2012-05-14 18:22:30 +04:00
|
|
|
SLOT(slotOwnCloudFound(QString,QString,QString,QString)));
|
2012-03-30 15:57:02 +04:00
|
|
|
|
2012-07-26 12:16:18 +04:00
|
|
|
connect( ownCloudInfo::instance(),SIGNAL(noOwncloudFound(QNetworkReply*)),
|
2012-04-10 16:51:45 +04:00
|
|
|
SLOT(slotNoOwnCloudFound(QNetworkReply*)));
|
2012-03-30 15:57:02 +04:00
|
|
|
|
2012-07-26 12:16:18 +04:00
|
|
|
connect( ownCloudInfo::instance(),SIGNAL(ownCloudDirExists(QString,QNetworkReply*)),
|
2012-03-30 22:42:40 +04:00
|
|
|
this,SLOT(slotAuthCheck(QString,QNetworkReply*)));
|
|
|
|
|
2012-07-26 12:16:18 +04:00
|
|
|
_owncloudSetupWizard = new OwncloudSetupWizard( _folderMan, _theme, this );
|
2012-06-12 14:28:58 +04:00
|
|
|
connect( _owncloudSetupWizard, SIGNAL(ownCloudWizardDone(int)), SLOT(slotStartFolderSetup(int)));
|
2012-02-21 16:26:39 +04:00
|
|
|
|
2012-02-20 19:45:27 +04:00
|
|
|
_statusDialog = new StatusDialog( _theme );
|
2012-02-21 16:26:39 +04:00
|
|
|
connect( _statusDialog, SIGNAL(addASync()), this, SLOT(slotAddFolder()) );
|
2011-04-04 13:36:44 +04:00
|
|
|
|
2011-10-13 15:55:52 +04:00
|
|
|
connect( _statusDialog, SIGNAL(removeFolderAlias( const QString&)),
|
|
|
|
SLOT(slotRemoveFolder(const QString&)));
|
2012-06-05 17:11:29 +04:00
|
|
|
|
|
|
|
connect( _statusDialog, SIGNAL(openLogBrowser()), this, SLOT(slotOpenLogBrowser()));
|
|
|
|
|
2012-02-19 00:21:58 +04:00
|
|
|
#if 0
|
2011-10-18 12:22:24 +04:00
|
|
|
connect( _statusDialog, SIGNAL(fetchFolderAlias(const QString&)),
|
|
|
|
SLOT(slotFetchFolder( const QString&)));
|
2011-12-05 15:01:39 +04:00
|
|
|
connect( _statusDialog, SIGNAL(pushFolderAlias(const QString&)),
|
|
|
|
SLOT(slotPushFolder( const QString&)));
|
2012-02-19 00:21:58 +04:00
|
|
|
#endif
|
2011-12-12 20:47:30 +04:00
|
|
|
connect( _statusDialog, SIGNAL(enableFolderAlias(QString,bool)),
|
|
|
|
SLOT(slotEnableFolder(QString,bool)));
|
2012-01-24 01:10:01 +04:00
|
|
|
connect( _statusDialog, SIGNAL(infoFolderAlias(const QString&)),
|
|
|
|
SLOT(slotInfoFolder( const QString&)));
|
2012-03-08 15:08:53 +04:00
|
|
|
connect( _statusDialog, SIGNAL(openFolderAlias(const QString&)),
|
|
|
|
SLOT(slotFolderOpenAction(QString)));
|
2011-12-12 20:47:30 +04:00
|
|
|
|
2012-04-21 23:03:29 +04:00
|
|
|
#if QT_VERSION >= 0x040700
|
2011-04-04 13:36:44 +04:00
|
|
|
qDebug() << "* Network is" << (_networkMgr->isOnline() ? "online" : "offline");
|
2012-05-21 18:48:49 +04:00
|
|
|
foreach (const QNetworkConfiguration& netCfg, _networkMgr->allConfigurations(QNetworkConfiguration::Active)) {
|
2011-04-04 13:36:44 +04:00
|
|
|
//qDebug() << "Network:" << netCfg.identifier();
|
|
|
|
}
|
2012-04-21 23:03:29 +04:00
|
|
|
#endif
|
2011-04-04 13:36:44 +04:00
|
|
|
|
2012-02-21 14:50:19 +04:00
|
|
|
setupActions();
|
2012-03-31 13:31:28 +04:00
|
|
|
setupSystemTray();
|
2012-07-31 12:17:52 +04:00
|
|
|
setupProxy();
|
2012-03-31 13:31:28 +04:00
|
|
|
processEvents();
|
2011-04-04 13:36:44 +04:00
|
|
|
|
2012-07-30 18:10:48 +04:00
|
|
|
QObject::connect( this, SIGNAL(messageReceived(QString)),
|
|
|
|
this, SLOT(slotOpenStatus()) );
|
|
|
|
|
2012-03-29 11:41:30 +04:00
|
|
|
QTimer::singleShot( 0, this, SLOT( slotStartFolderSetup() ));
|
2012-02-23 14:44:44 +04:00
|
|
|
|
2012-04-02 22:10:29 +04:00
|
|
|
MirallConfigFile cfg;
|
|
|
|
if( !cfg.ownCloudSkipUpdateCheck() ) {
|
|
|
|
QTimer::singleShot( 3000, this, SLOT( slotStartUpdateDetector() ));
|
|
|
|
}
|
|
|
|
|
2011-11-04 14:41:49 +04:00
|
|
|
qDebug() << "Network Location: " << NetworkLocation::currentLocation().encoded();
|
2011-02-17 02:21:45 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
Application::~Application()
|
|
|
|
{
|
2011-04-05 20:31:19 +04:00
|
|
|
qDebug() << "* Mirall shutdown";
|
2012-03-29 11:41:30 +04:00
|
|
|
}
|
|
|
|
|
2012-04-02 22:10:29 +04:00
|
|
|
void Application::slotStartUpdateDetector()
|
|
|
|
{
|
|
|
|
_updateDetector = new UpdateDetector(this);
|
|
|
|
_updateDetector->versionCheck(_theme);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2012-06-12 14:28:58 +04:00
|
|
|
void Application::slotStartFolderSetup( int result )
|
2012-03-29 11:41:30 +04:00
|
|
|
{
|
2012-06-12 14:28:58 +04:00
|
|
|
if( result == QDialog::Accepted ) {
|
2012-07-26 12:16:18 +04:00
|
|
|
if( ownCloudInfo::instance()->isConfigured() ) {
|
|
|
|
ownCloudInfo::instance()->checkInstallation();
|
2012-06-12 14:28:58 +04:00
|
|
|
} else {
|
|
|
|
QMessageBox::warning(0, tr("No ownCloud Configuration"),
|
2012-06-15 12:51:51 +04:00
|
|
|
tr("<p>No server connection has been configured for this ownCloud client.</p>"
|
|
|
|
"<p>Please right click on the ownCloud system tray icon and select <i>Configure</i> "
|
|
|
|
"to connect this client to an ownCloud server.</p>"));
|
2012-06-12 14:28:58 +04:00
|
|
|
// It was evaluated to open the config dialog from here directly but decided
|
|
|
|
// against because the user does not know why. The popup gives a better user
|
|
|
|
// guidance, even if its a click more.
|
|
|
|
}
|
2012-03-29 11:41:30 +04:00
|
|
|
} else {
|
2012-06-12 14:28:58 +04:00
|
|
|
qDebug() << "Setup Wizard was canceled. No reparsing of config.";
|
2012-03-29 11:41:30 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-05-14 18:22:30 +04:00
|
|
|
void Application::slotOwnCloudFound( const QString& url, const QString& versionStr, const QString& version, const QString& edition)
|
2012-03-29 11:41:30 +04:00
|
|
|
{
|
2012-05-14 18:22:30 +04:00
|
|
|
qDebug() << "** Application: ownCloud found: " << url << " with version " << versionStr << "(" << version << ")";
|
|
|
|
// now check the authentication
|
|
|
|
MirallConfigFile cfgFile;
|
|
|
|
cfgFile.setOwnCloudVersion( version );
|
|
|
|
|
2012-07-30 18:10:48 +04:00
|
|
|
// disconnect from ownCloudInfo
|
|
|
|
disconnect( ownCloudInfo::instance(),SIGNAL(ownCloudInfoFound(QString,QString,QString,QString)),
|
|
|
|
this, SLOT(slotOwnCloudFound(QString,QString,QString,QString)));
|
|
|
|
|
|
|
|
disconnect( ownCloudInfo::instance(),SIGNAL(noOwncloudFound(QNetworkReply*)),
|
|
|
|
this, SLOT(slotNoOwnCloudFound(QNetworkReply*)));
|
|
|
|
|
2012-03-30 22:42:40 +04:00
|
|
|
QTimer::singleShot( 0, this, SLOT( slotCheckAuthentication() ));
|
2012-03-29 11:41:30 +04:00
|
|
|
}
|
|
|
|
|
2012-04-10 16:51:45 +04:00
|
|
|
void Application::slotNoOwnCloudFound( QNetworkReply* reply )
|
2012-03-29 11:41:30 +04:00
|
|
|
{
|
|
|
|
qDebug() << "** Application: NO ownCloud found!";
|
2012-04-10 16:51:45 +04:00
|
|
|
QString msg;
|
|
|
|
if( reply ) {
|
2012-04-10 22:55:50 +04:00
|
|
|
QString url( reply->url().toString() );
|
|
|
|
url.remove( "/status.php" );
|
|
|
|
msg = tr("<p>The ownCloud at %1 could not be reached.</p>").arg( url );
|
2012-04-10 16:51:45 +04:00
|
|
|
msg += tr("<p>The detailed error message is<br/><tt>%1</tt></p>").arg( reply->errorString() );
|
|
|
|
}
|
|
|
|
msg += tr("<p>Please check your configuration by clicking on the tray icon.</p>");
|
|
|
|
|
|
|
|
QMessageBox::warning(0, tr("ownCloud Connection Failed"), msg );
|
2012-03-30 15:57:02 +04:00
|
|
|
_actionAddFolder->setEnabled( false );
|
|
|
|
setupContextMenu();
|
2011-04-04 13:36:44 +04:00
|
|
|
}
|
2012-04-02 15:21:13 +04:00
|
|
|
|
2012-03-30 22:42:40 +04:00
|
|
|
void Application::slotCheckAuthentication()
|
|
|
|
{
|
2012-04-06 10:53:57 +04:00
|
|
|
qDebug() << "# checking for authentication settings.";
|
2012-07-26 12:16:18 +04:00
|
|
|
ownCloudInfo::instance()->getRequest("/", true ); // this call needs to be authenticated.
|
2012-03-30 22:42:40 +04:00
|
|
|
// simply GET the webdav root, will fail if credentials are wrong.
|
|
|
|
// continue in slotAuthCheck here :-)
|
|
|
|
}
|
|
|
|
|
|
|
|
void Application::slotAuthCheck( const QString& ,QNetworkReply *reply )
|
|
|
|
{
|
2012-04-17 15:06:25 +04:00
|
|
|
if( reply->error() == QNetworkReply::AuthenticationRequiredError ) { // returned if the user is wrong.
|
|
|
|
qDebug() << "******** Password is wrong!";
|
2012-03-30 22:42:40 +04:00
|
|
|
QMessageBox::warning(0, tr("No ownCloud Connection"),
|
2012-04-10 22:55:50 +04:00
|
|
|
tr("<p>Your ownCloud credentials are not correct.</p>"
|
|
|
|
"<p>Please correct them by starting the configuration dialog from the tray!</p>"));
|
2012-03-30 22:42:40 +04:00
|
|
|
_actionAddFolder->setEnabled( false );
|
2012-04-17 15:06:25 +04:00
|
|
|
} else if( reply->error() == QNetworkReply::OperationCanceledError ) {
|
|
|
|
// the username was wrong and ownCloudInfo was closing the request after a couple of auth tries.
|
2012-04-18 13:59:56 +04:00
|
|
|
qDebug() << "******** Username or password is wrong!";
|
2012-04-17 15:06:25 +04:00
|
|
|
QMessageBox::warning(0, tr("No ownCloud Connection"),
|
2012-04-18 13:59:56 +04:00
|
|
|
tr("<p>Your ownCloud user name or password is not correct.</p>"
|
2012-04-17 15:06:25 +04:00
|
|
|
"<p>Please correct it by starting the configuration dialog from the tray!</p>"));
|
|
|
|
_actionAddFolder->setEnabled( false );
|
2012-03-30 22:42:40 +04:00
|
|
|
} else {
|
|
|
|
qDebug() << "######## Credentials are ok!";
|
|
|
|
int cnt = _folderMan->setupFolders();
|
|
|
|
if( cnt ) {
|
2012-05-02 17:50:01 +04:00
|
|
|
_tray->setIcon(_theme->applicationIcon());
|
2012-03-30 22:42:40 +04:00
|
|
|
_tray->show();
|
2012-03-31 13:31:28 +04:00
|
|
|
processEvents();
|
|
|
|
|
2012-03-30 22:42:40 +04:00
|
|
|
if( _tray )
|
|
|
|
_tray->showMessage(tr("ownCloud Sync Started"), tr("Sync started for %1 configured sync folder(s).").arg(cnt));
|
|
|
|
}
|
|
|
|
_actionAddFolder->setEnabled( true );
|
|
|
|
}
|
2012-07-30 18:10:48 +04:00
|
|
|
|
|
|
|
// disconnect from ownCloud Info signals
|
|
|
|
disconnect( ownCloudInfo::instance(),SIGNAL(ownCloudDirExists(QString,QNetworkReply*)),
|
|
|
|
this,SLOT(slotAuthCheck(QString,QNetworkReply*)));
|
2012-03-30 22:42:40 +04:00
|
|
|
setupContextMenu();
|
|
|
|
}
|
2011-04-04 13:36:44 +04:00
|
|
|
|
2011-02-17 02:21:45 +03:00
|
|
|
void Application::setupActions()
|
|
|
|
{
|
2012-05-15 20:29:12 +04:00
|
|
|
_actionOpenoC = new QAction(tr("Open ownCloud..."), this);
|
|
|
|
QObject::connect(_actionOpenoC, SIGNAL(triggered(bool)), SLOT(slotOpenOwnCloud()));
|
2012-04-30 18:38:00 +04:00
|
|
|
_actionOpenStatus = new QAction(tr("Open status..."), this);
|
|
|
|
QObject::connect(_actionOpenStatus, SIGNAL(triggered(bool)), SLOT(slotOpenStatus()));
|
2011-10-14 18:39:53 +04:00
|
|
|
_actionAddFolder = new QAction(tr("Add folder..."), this);
|
2011-02-17 02:21:45 +03:00
|
|
|
QObject::connect(_actionAddFolder, SIGNAL(triggered(bool)), SLOT(slotAddFolder()));
|
2011-10-14 18:39:53 +04:00
|
|
|
_actionConfigure = new QAction(tr("Configure..."), this);
|
|
|
|
QObject::connect(_actionConfigure, SIGNAL(triggered(bool)), SLOT(slotConfigure()));
|
2012-07-31 12:17:52 +04:00
|
|
|
_actionConfigureProxy = new QAction(tr("Configure proxy..."), this);
|
|
|
|
QObject::connect(_actionConfigureProxy, SIGNAL(triggered(bool)), SLOT(slotConfigureProxy()));
|
2012-02-21 14:50:19 +04:00
|
|
|
|
2011-02-17 02:21:45 +03:00
|
|
|
_actionQuit = new QAction(tr("Quit"), this);
|
|
|
|
QObject::connect(_actionQuit, SIGNAL(triggered(bool)), SLOT(quit()));
|
|
|
|
}
|
|
|
|
|
|
|
|
void Application::setupSystemTray()
|
|
|
|
{
|
2012-08-02 13:08:27 +04:00
|
|
|
_tray = new QSystemTrayIcon(this);
|
2012-05-02 19:05:31 +04:00
|
|
|
_tray->setIcon( _theme->applicationIcon() ); // load the grey icon
|
2011-09-26 17:00:12 +04:00
|
|
|
|
|
|
|
connect(_tray,SIGNAL(activated(QSystemTrayIcon::ActivationReason)),
|
|
|
|
SLOT(slotTrayClicked(QSystemTrayIcon::ActivationReason)));
|
|
|
|
|
2012-04-10 16:51:45 +04:00
|
|
|
setupContextMenu();
|
|
|
|
|
2011-02-17 02:21:45 +03:00
|
|
|
_tray->show();
|
|
|
|
}
|
|
|
|
|
2012-02-21 14:50:19 +04:00
|
|
|
void Application::setupContextMenu()
|
|
|
|
{
|
2012-03-31 13:31:28 +04:00
|
|
|
if( _contextMenu ) {
|
|
|
|
_contextMenu->clear();
|
|
|
|
} else {
|
|
|
|
_contextMenu = new QMenu();
|
|
|
|
}
|
2012-02-21 14:50:19 +04:00
|
|
|
_contextMenu->setTitle(_theme->appName() );
|
2012-04-30 18:38:00 +04:00
|
|
|
_contextMenu->addAction(_actionOpenStatus);
|
2012-05-15 20:29:12 +04:00
|
|
|
_contextMenu->addAction(_actionOpenoC);
|
2012-08-02 13:15:57 +04:00
|
|
|
|
2012-02-21 14:50:19 +04:00
|
|
|
_contextMenu->addSeparator();
|
|
|
|
|
2012-08-02 13:15:57 +04:00
|
|
|
if (!_folderMan->map().isEmpty())
|
|
|
|
_contextMenu->addAction(tr("Managed Folders:"))->setDisabled(true);
|
|
|
|
|
2012-02-21 14:50:19 +04:00
|
|
|
// here all folders should be added
|
|
|
|
foreach (Folder *folder, _folderMan->map() ) {
|
2012-08-02 13:15:57 +04:00
|
|
|
QAction *action = new QAction( folder->alias(), this );
|
2012-05-02 17:50:01 +04:00
|
|
|
action->setIcon( _theme->trayFolderIcon( folder->backend()) );
|
2012-02-21 14:50:19 +04:00
|
|
|
|
|
|
|
connect( action, SIGNAL(triggered()),_folderOpenActionMapper,SLOT(map()));
|
|
|
|
_folderOpenActionMapper->setMapping( action, folder->alias() );
|
|
|
|
|
|
|
|
_contextMenu->addAction(action);
|
|
|
|
}
|
2012-08-02 13:15:57 +04:00
|
|
|
_contextMenu->addAction(_actionAddFolder);
|
2012-02-21 14:50:19 +04:00
|
|
|
|
2012-08-02 13:15:57 +04:00
|
|
|
_contextMenu->addSeparator();
|
|
|
|
_contextMenu->addAction(_actionConfigure);
|
|
|
|
_contextMenu->addAction(_actionConfigureProxy);
|
2012-02-21 14:50:19 +04:00
|
|
|
_contextMenu->addSeparator();
|
|
|
|
|
|
|
|
_contextMenu->addAction(_actionQuit);
|
|
|
|
_tray->setContextMenu(_contextMenu);
|
|
|
|
}
|
|
|
|
|
2012-06-05 17:49:53 +04:00
|
|
|
void Application::setupLogBrowser()
|
|
|
|
{
|
|
|
|
// init the log browser.
|
|
|
|
_logBrowser = new LogBrowser;
|
|
|
|
qInstallMsgHandler( mirallLogCatcher );
|
|
|
|
csync_set_log_callback( csyncLogCatcher );
|
|
|
|
|
|
|
|
if( arguments().contains("--logwindow") || arguments().contains("-l")) {
|
|
|
|
slotOpenLogBrowser();
|
|
|
|
}
|
|
|
|
|
2012-06-15 15:04:23 +04:00
|
|
|
// check for command line option for a log file.
|
|
|
|
int lf = arguments().indexOf("--logfile");
|
|
|
|
|
|
|
|
if( lf > -1 && lf+1 < arguments().count() ) {
|
|
|
|
QString logfile = arguments().at( lf+1 );
|
|
|
|
|
|
|
|
bool flush = false;
|
|
|
|
if( arguments().contains("--logflush")) flush = true;
|
|
|
|
|
|
|
|
qDebug() << "Logging into logfile: " << logfile << " with flush " << flush;
|
|
|
|
_logBrowser->setLogFile( logfile, flush );
|
|
|
|
}
|
|
|
|
|
2012-06-05 17:49:53 +04:00
|
|
|
qDebug() << QString( "################## %1 %2 %3 ").arg(_theme->appName())
|
|
|
|
.arg( QLocale::system().name() )
|
|
|
|
.arg(_theme->version());
|
|
|
|
}
|
2012-07-31 12:17:52 +04:00
|
|
|
|
|
|
|
void Application::setupProxy()
|
|
|
|
{
|
|
|
|
//
|
|
|
|
// TODO: push proxy information to csync
|
|
|
|
//
|
|
|
|
Mirall::MirallConfigFile cfg;
|
|
|
|
switch(cfg.proxyType())
|
|
|
|
{
|
|
|
|
case QNetworkProxy::NoProxy:
|
|
|
|
{
|
|
|
|
QNetworkProxy proxy;
|
|
|
|
proxy.setType(QNetworkProxy::NoProxy);
|
|
|
|
QNetworkProxy::setApplicationProxy(proxy);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case QNetworkProxy::DefaultProxy:
|
|
|
|
{
|
|
|
|
QNetworkProxyFactory::setUseSystemConfiguration(true);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case QNetworkProxy::Socks5Proxy:
|
|
|
|
{
|
|
|
|
QNetworkProxy proxy;
|
|
|
|
proxy.setType(QNetworkProxy::Socks5Proxy);
|
|
|
|
proxy.setHostName(cfg.proxyHostName());
|
|
|
|
proxy.setPort(cfg.proxyPort());
|
|
|
|
proxy.setUser(cfg.proxyUser());
|
|
|
|
proxy.setPassword(cfg.proxyPassword());
|
|
|
|
QNetworkProxy::setApplicationProxy(proxy);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-02-21 14:50:19 +04:00
|
|
|
/*
|
|
|
|
* open the folder with the given Alais
|
|
|
|
*/
|
|
|
|
void Application::slotFolderOpenAction( const QString& alias )
|
|
|
|
{
|
|
|
|
Folder *f = _folderMan->folder(alias);
|
2012-04-02 14:13:55 +04:00
|
|
|
qDebug() << "opening local url " << f->path();
|
2012-02-21 14:50:19 +04:00
|
|
|
if( f ) {
|
2012-04-02 14:13:55 +04:00
|
|
|
QUrl url(f->path(), QUrl::TolerantMode);
|
|
|
|
url.setScheme( "file" );
|
2012-05-16 13:42:47 +04:00
|
|
|
|
|
|
|
#ifdef Q_OS_WIN32
|
|
|
|
// work around a bug in QDesktopServices on Win32, see i-net
|
|
|
|
QString filePath = f->path();
|
|
|
|
|
2012-05-26 15:25:05 +04:00
|
|
|
if (filePath.startsWith("\\\\") || filePath.startsWith("//"))
|
2012-05-16 13:42:47 +04:00
|
|
|
url.setUrl(QDir::toNativeSeparators(filePath));
|
|
|
|
else
|
|
|
|
url = QUrl::fromLocalFile(filePath);
|
|
|
|
#endif
|
2012-04-02 14:13:55 +04:00
|
|
|
QDesktopServices::openUrl(url);
|
2012-02-21 14:50:19 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-05-15 20:29:12 +04:00
|
|
|
void Application::slotOpenOwnCloud()
|
|
|
|
{
|
|
|
|
MirallConfigFile cfgFile;
|
|
|
|
|
|
|
|
QString url = cfgFile.ownCloudUrl();
|
|
|
|
QDesktopServices::openUrl( url );
|
|
|
|
}
|
|
|
|
|
2011-09-26 17:00:12 +04:00
|
|
|
void Application::slotTrayClicked( QSystemTrayIcon::ActivationReason reason )
|
|
|
|
{
|
2012-05-15 19:52:30 +04:00
|
|
|
// A click on the tray icon should only open the status window on Win and
|
|
|
|
// Linux, not on Mac. They want a menu entry.
|
2012-04-30 18:38:00 +04:00
|
|
|
#if defined Q_WS_WIN || defined Q_WS_X11
|
2012-05-15 19:52:30 +04:00
|
|
|
if( reason == QSystemTrayIcon::Trigger ) {
|
|
|
|
slotOpenStatus();
|
2011-09-26 17:00:12 +04:00
|
|
|
}
|
2012-05-15 19:52:30 +04:00
|
|
|
#endif
|
2011-09-26 17:00:12 +04:00
|
|
|
}
|
|
|
|
|
2011-02-17 02:21:45 +03:00
|
|
|
void Application::slotAddFolder()
|
|
|
|
{
|
2012-02-17 12:48:31 +04:00
|
|
|
_folderMan->disableFoldersWithRestore();
|
2011-11-03 19:06:40 +04:00
|
|
|
|
2012-02-17 12:48:31 +04:00
|
|
|
Folder::Map folderMap = _folderMan->map();
|
|
|
|
|
|
|
|
_folderWizard->setFolderMap( &folderMap );
|
2011-10-11 16:23:32 +04:00
|
|
|
|
2011-10-14 20:13:34 +04:00
|
|
|
_folderWizard->restart();
|
|
|
|
|
2011-10-11 16:23:32 +04:00
|
|
|
if (_folderWizard->exec() == QDialog::Accepted) {
|
|
|
|
qDebug() << "* Folder wizard completed";
|
|
|
|
|
2012-02-17 12:48:31 +04:00
|
|
|
bool goodData = true;
|
2011-10-11 16:23:32 +04:00
|
|
|
|
2012-02-17 12:48:31 +04:00
|
|
|
QString alias = _folderWizard->field("alias").toString();
|
|
|
|
QString sourceFolder = _folderWizard->field("sourceFolder").toString();
|
|
|
|
QString backend = QString::fromLocal8Bit("csync");
|
|
|
|
QString targetPath;
|
|
|
|
bool onlyThisLAN = false;
|
|
|
|
bool onlyOnline = false;
|
2011-10-11 16:23:32 +04:00
|
|
|
|
|
|
|
if (_folderWizard->field("local?").toBool()) {
|
2012-02-17 12:48:31 +04:00
|
|
|
// setup a local csync folder
|
|
|
|
targetPath = _folderWizard->field("targetLocalFolder").toString();
|
2011-10-11 16:23:32 +04:00
|
|
|
} else if (_folderWizard->field("remote?").toBool()) {
|
2012-02-17 12:48:31 +04:00
|
|
|
// setup a remote csync folder
|
|
|
|
targetPath = _folderWizard->field("targetURLFolder").toString();
|
|
|
|
onlyOnline = _folderWizard->field("onlyOnline?").toBool();
|
|
|
|
onlyThisLAN = _folderWizard->field("onlyThisLAN?").toBool();
|
2011-10-11 16:23:32 +04:00
|
|
|
} else if( _folderWizard->field("OC?").toBool()) {
|
2012-02-17 12:48:31 +04:00
|
|
|
// setup a ownCloud folder
|
|
|
|
backend = QString::fromLocal8Bit("owncloud");
|
|
|
|
targetPath = _folderWizard->field("targetOCFolder").toString();
|
2011-10-11 16:23:32 +04:00
|
|
|
} else {
|
|
|
|
qWarning() << "* Folder not local and note remote?";
|
2012-02-17 12:48:31 +04:00
|
|
|
goodData = false;
|
2011-04-05 20:31:14 +04:00
|
|
|
}
|
2011-10-11 16:23:32 +04:00
|
|
|
|
2012-02-17 12:48:31 +04:00
|
|
|
if( goodData ) {
|
|
|
|
_folderMan->addFolderDefinition( backend, alias, sourceFolder, targetPath, onlyThisLAN );
|
2012-04-20 16:41:40 +04:00
|
|
|
Folder *f = _folderMan->setupFolderFromConfigFile( alias );
|
|
|
|
if( f ) {
|
|
|
|
_statusDialog->slotAddFolder( f );
|
|
|
|
setupContextMenu();
|
|
|
|
}
|
2012-02-17 12:48:31 +04:00
|
|
|
}
|
|
|
|
|
2011-12-12 20:47:30 +04:00
|
|
|
} else {
|
2011-10-11 16:23:32 +04:00
|
|
|
qDebug() << "* Folder wizard cancelled";
|
2011-12-12 20:47:30 +04:00
|
|
|
}
|
2012-02-17 12:48:31 +04:00
|
|
|
_folderMan->restoreEnabledFolders();
|
2011-02-17 02:21:45 +03:00
|
|
|
}
|
|
|
|
|
2012-04-30 18:38:00 +04:00
|
|
|
void Application::slotOpenStatus()
|
|
|
|
{
|
|
|
|
if( ! _statusDialog ) return;
|
2012-05-15 19:52:30 +04:00
|
|
|
|
|
|
|
QWidget *raiseWidget = 0;
|
|
|
|
|
|
|
|
// check if there is a mirall.cfg already.
|
|
|
|
if( _owncloudSetupWizard->wizard()->isVisible() ) {
|
|
|
|
raiseWidget = _owncloudSetupWizard->wizard();
|
|
|
|
}
|
|
|
|
|
|
|
|
// if no config file is there, start the configuration wizard.
|
|
|
|
if( ! raiseWidget ) {
|
|
|
|
MirallConfigFile cfgFile;
|
|
|
|
|
|
|
|
if( !cfgFile.exists() ) {
|
|
|
|
qDebug() << "No configured folders yet, start the Owncloud integration dialog.";
|
|
|
|
_owncloudSetupWizard->startWizard();
|
|
|
|
} else {
|
|
|
|
qDebug() << "#============# Status dialog starting #=============#";
|
|
|
|
raiseWidget = _statusDialog;
|
|
|
|
_statusDialog->setFolderList( _folderMan->map() );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// viel hilft viel ;-)
|
|
|
|
if( raiseWidget ) {
|
2012-07-31 03:57:02 +04:00
|
|
|
#if defined(Q_WS_WIN) || defined (Q_OS_MAC)
|
2012-05-15 19:52:30 +04:00
|
|
|
Qt::WindowFlags eFlags = raiseWidget->windowFlags();
|
|
|
|
eFlags |= Qt::WindowStaysOnTopHint;
|
|
|
|
raiseWidget->setWindowFlags(eFlags);
|
|
|
|
raiseWidget->show();
|
|
|
|
eFlags &= ~Qt::WindowStaysOnTopHint;
|
|
|
|
raiseWidget->setWindowFlags(eFlags);
|
|
|
|
#endif
|
|
|
|
raiseWidget->show();
|
|
|
|
raiseWidget->raise();
|
|
|
|
raiseWidget->activateWindow();
|
|
|
|
}
|
2012-04-30 18:38:00 +04:00
|
|
|
}
|
|
|
|
|
2012-06-05 17:11:29 +04:00
|
|
|
void Application::slotOpenLogBrowser()
|
|
|
|
{
|
|
|
|
_logBrowser->show();
|
|
|
|
_logBrowser->raise();
|
|
|
|
}
|
|
|
|
|
2012-03-16 13:39:20 +04:00
|
|
|
/*
|
|
|
|
* the folder is to be removed. The slot is called from a signal emitted by
|
|
|
|
* the status dialog, which removes the folder from its list by itself.
|
|
|
|
*/
|
2011-10-13 15:55:52 +04:00
|
|
|
void Application::slotRemoveFolder( const QString& alias )
|
|
|
|
{
|
2012-03-16 13:39:20 +04:00
|
|
|
int ret = QMessageBox::question( 0, tr("Confirm Folder Remove"), tr("Do you really want to remove upload folder <i>%1</i>?").arg(alias),
|
|
|
|
QMessageBox::Yes|QMessageBox::No );
|
2011-10-13 15:55:52 +04:00
|
|
|
|
2012-03-16 13:39:20 +04:00
|
|
|
if( ret == QMessageBox::No ) {
|
|
|
|
return;
|
|
|
|
}
|
2012-05-14 15:23:04 +04:00
|
|
|
Folder *f = _folderMan->folder(alias);
|
2012-07-30 18:10:48 +04:00
|
|
|
if( f && _overallStatusStrings.contains( f->alias() )) {
|
|
|
|
_overallStatusStrings.remove( f->alias() );
|
2012-05-14 15:23:04 +04:00
|
|
|
}
|
2011-10-13 15:55:52 +04:00
|
|
|
|
2012-03-16 13:39:20 +04:00
|
|
|
_folderMan->slotRemoveFolder( alias );
|
2012-03-29 11:41:30 +04:00
|
|
|
_statusDialog->slotRemoveSelectedFolder( );
|
2012-05-14 15:23:04 +04:00
|
|
|
computeOverallSyncStatus();
|
2012-04-20 16:41:40 +04:00
|
|
|
setupContextMenu();
|
2011-10-13 15:55:52 +04:00
|
|
|
}
|
|
|
|
|
2012-01-24 01:10:01 +04:00
|
|
|
void Application::slotInfoFolder( const QString& alias )
|
|
|
|
{
|
|
|
|
qDebug() << "details of folder with alias " << alias;
|
|
|
|
|
2012-02-17 12:48:31 +04:00
|
|
|
SyncResult folderResult = _folderMan->syncResult( alias );
|
2012-01-24 01:10:01 +04:00
|
|
|
|
2012-04-30 10:56:56 +04:00
|
|
|
bool enabled = true;
|
|
|
|
Folder *f = _folderMan->folder( alias );
|
|
|
|
if( f && ! f->syncEnabled() ) {
|
|
|
|
enabled = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
QString folderMessage;
|
2012-02-17 12:48:31 +04:00
|
|
|
|
2012-02-20 19:45:27 +04:00
|
|
|
SyncResult::Status syncStatus = folderResult.status();
|
2012-04-30 10:56:56 +04:00
|
|
|
switch( syncStatus ) {
|
|
|
|
case SyncResult::Undefined:
|
|
|
|
folderMessage = tr( "Undefined Folder State" );
|
|
|
|
break;
|
|
|
|
case SyncResult::NotYetStarted:
|
|
|
|
folderMessage = tr( "The folder waits to start syncing." );
|
|
|
|
break;
|
|
|
|
case SyncResult::SyncRunning:
|
|
|
|
folderMessage = tr("Sync is running.");
|
|
|
|
break;
|
|
|
|
case SyncResult::Success:
|
|
|
|
folderMessage = tr("Last Sync was successful.");
|
|
|
|
break;
|
|
|
|
case SyncResult::Error:
|
|
|
|
folderMessage = tr( "Syncing Error." );
|
|
|
|
break;
|
|
|
|
case SyncResult::SetupError:
|
|
|
|
folderMessage = tr( "Setup Error." );
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
folderMessage = tr( "Undefined Error State." );
|
2012-01-24 01:10:01 +04:00
|
|
|
}
|
2012-04-30 10:56:56 +04:00
|
|
|
folderMessage = QLatin1String("<b>") + folderMessage + QLatin1String("</b><br/>");
|
2012-01-24 01:10:01 +04:00
|
|
|
|
2012-02-17 12:48:31 +04:00
|
|
|
QMessageBox infoBox( QMessageBox::Information, tr( "Folder information" ), alias, QMessageBox::Ok );
|
2012-03-22 19:22:08 +04:00
|
|
|
QStringList li = folderResult.errorStrings();
|
2012-05-21 18:48:49 +04:00
|
|
|
foreach( const QString& l, li ) {
|
2012-04-30 10:56:56 +04:00
|
|
|
folderMessage += QString("<p>%1</p>").arg( l );
|
2012-03-22 19:22:08 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
infoBox.setText( folderMessage );
|
2012-01-24 01:10:01 +04:00
|
|
|
|
2012-03-22 19:22:08 +04:00
|
|
|
// qDebug() << "informative text: " << infoBox.informativeText();
|
2012-01-24 01:10:01 +04:00
|
|
|
|
|
|
|
if ( !folderResult.syncChanges().isEmpty() ) {
|
2012-07-31 12:17:52 +04:00
|
|
|
QString details;
|
|
|
|
QHash < QString, QStringList > changes = folderResult.syncChanges();
|
|
|
|
QHash< QString, QStringList >::const_iterator change_it = changes.constBegin();
|
|
|
|
for(; change_it != changes.constEnd(); ++change_it ) {
|
|
|
|
QString changeType = tr( "Unknown" );
|
|
|
|
if ( change_it.key() == "changed" ) {
|
|
|
|
changeType = tr( "Changed files:\n" );
|
|
|
|
} else if ( change_it.key() == "added" ) {
|
|
|
|
changeType = tr( "Added files:\n" );
|
|
|
|
} else if ( change_it.key() == "deleted" ) {
|
|
|
|
changeType = tr( "New files in the server, or files deleted locally:\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
QStringList files = change_it.value();
|
|
|
|
QString fileList;
|
|
|
|
foreach( const QString& file, files) {
|
|
|
|
fileList += file + QChar('\n');
|
|
|
|
}
|
|
|
|
details += changeType + fileList;
|
|
|
|
}
|
|
|
|
infoBox.setDetailedText(details);
|
|
|
|
qDebug() << "detailed text: " << infoBox.detailedText();
|
2012-01-24 01:10:01 +04:00
|
|
|
}
|
|
|
|
infoBox.exec();
|
|
|
|
}
|
|
|
|
|
2011-12-12 20:47:30 +04:00
|
|
|
void Application::slotEnableFolder(const QString& alias, const bool enable)
|
|
|
|
{
|
2012-03-03 13:51:06 +04:00
|
|
|
qDebug() << "Application: enable folder with alias " << alias;
|
2011-12-12 20:47:30 +04:00
|
|
|
|
2012-02-17 12:48:31 +04:00
|
|
|
_folderMan->slotEnableFolder( alias, enable );
|
2012-04-30 10:56:56 +04:00
|
|
|
|
|
|
|
// this sets the folder status to disabled but does not interrupt it.
|
|
|
|
Folder *f = _folderMan->folder( alias );
|
|
|
|
if( f && !enable ) {
|
|
|
|
// check if a sync is still running and if so, ask if we should terminate.
|
|
|
|
if( f->isBusy() ) { // its still running
|
|
|
|
QMessageBox::StandardButton b = QMessageBox::question( 0, tr("Sync Running"),
|
|
|
|
tr("The syncing operation is running.<br/>Do you want to terminate it?"),
|
|
|
|
QMessageBox::Yes | QMessageBox::No, QMessageBox::Yes );
|
|
|
|
if( b == QMessageBox::Yes ) {
|
|
|
|
_folderMan->terminateSyncProcess( alias );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
_statusDialog->slotUpdateFolderState( f );
|
2011-12-12 20:47:30 +04:00
|
|
|
}
|
|
|
|
|
2011-10-14 18:39:53 +04:00
|
|
|
void Application::slotConfigure()
|
|
|
|
{
|
2012-02-17 12:48:31 +04:00
|
|
|
_folderMan->disableFoldersWithRestore();
|
2012-02-17 14:11:18 +04:00
|
|
|
_owncloudSetupWizard->startWizard();
|
2012-02-17 12:48:31 +04:00
|
|
|
_folderMan->restoreEnabledFolders();
|
2011-04-04 14:23:30 +04:00
|
|
|
}
|
|
|
|
|
2012-07-31 12:17:52 +04:00
|
|
|
void Application::slotConfigureProxy()
|
|
|
|
{
|
|
|
|
ProxyDialog* dlg = new ProxyDialog();
|
|
|
|
if (dlg->exec() == QDialog::Accepted)
|
|
|
|
{
|
|
|
|
setupProxy();
|
|
|
|
}
|
|
|
|
dlg->deleteLater();
|
|
|
|
}
|
|
|
|
|
2012-02-19 00:21:58 +04:00
|
|
|
void Application::slotSyncStateChange( const QString& alias )
|
2011-04-04 14:23:30 +04:00
|
|
|
{
|
2012-02-20 19:45:27 +04:00
|
|
|
SyncResult result = _folderMan->syncResult( alias );
|
2011-04-04 14:23:30 +04:00
|
|
|
|
2012-04-17 15:16:48 +04:00
|
|
|
// do not promote LocalSyncState to the status dialog.
|
|
|
|
if( !result.localRunOnly() ) {
|
|
|
|
_statusDialog->slotUpdateFolderState( _folderMan->folder(alias) );
|
|
|
|
}
|
2012-04-17 17:02:18 +04:00
|
|
|
computeOverallSyncStatus();
|
2012-02-19 00:21:58 +04:00
|
|
|
|
2012-07-30 18:10:48 +04:00
|
|
|
qDebug() << "Sync state changed for folder " << alias << ": " << result.statusString();
|
2012-01-24 01:10:01 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
void Application::computeOverallSyncStatus()
|
|
|
|
{
|
|
|
|
|
2012-05-21 18:48:49 +04:00
|
|
|
// display the info of the least successful sync (eg. not just display the result of the latest sync
|
2012-07-18 19:28:30 +04:00
|
|
|
SyncResult overallResult(SyncResult::Undefined );
|
2012-04-17 17:02:18 +04:00
|
|
|
QString trayMessage;
|
|
|
|
Folder::Map map = _folderMan->map();
|
|
|
|
|
2012-07-30 18:10:48 +04:00
|
|
|
foreach ( Folder *syncedFolder, map.values() ) {
|
|
|
|
QString folderMessage = _overallStatusStrings[syncedFolder->alias()];
|
2012-04-17 17:02:18 +04:00
|
|
|
|
|
|
|
SyncResult folderResult = syncedFolder->syncResult();
|
|
|
|
SyncResult::Status syncStatus = folderResult.status();
|
|
|
|
|
2012-05-14 13:51:47 +04:00
|
|
|
if( ! folderResult.localRunOnly() ) { // skip local runs, use the last message.
|
|
|
|
if( syncedFolder->syncEnabled() ) {
|
|
|
|
switch( syncStatus ) {
|
|
|
|
case SyncResult::Undefined:
|
|
|
|
if ( overallResult.status() != SyncResult::Error ) {
|
2012-07-26 12:16:18 +04:00
|
|
|
overallResult.setStatus(SyncResult::Error);
|
2012-05-14 13:51:47 +04:00
|
|
|
}
|
|
|
|
folderMessage = tr( "Undefined State." );
|
|
|
|
break;
|
|
|
|
case SyncResult::NotYetStarted:
|
|
|
|
folderMessage = tr( "Waits to start syncing." );
|
2012-07-18 19:28:30 +04:00
|
|
|
overallResult.setStatus( SyncResult::NotYetStarted );
|
2012-05-14 13:51:47 +04:00
|
|
|
break;
|
|
|
|
case SyncResult::SyncRunning:
|
|
|
|
folderMessage = tr( "Sync is running." );
|
2012-07-18 19:28:30 +04:00
|
|
|
overallResult.setStatus( SyncResult::SyncRunning );
|
2012-05-14 13:51:47 +04:00
|
|
|
break;
|
|
|
|
case SyncResult::Success:
|
2012-07-30 18:10:48 +04:00
|
|
|
if( overallResult.status() == SyncResult::Undefined ) {
|
|
|
|
folderMessage = tr( "Last Sync was successful." );
|
|
|
|
overallResult.setStatus( SyncResult::Success );
|
|
|
|
}
|
2012-05-14 13:51:47 +04:00
|
|
|
break;
|
|
|
|
case SyncResult::Error:
|
2012-07-18 19:28:30 +04:00
|
|
|
overallResult.setStatus( SyncResult::Error );
|
2012-05-14 13:51:47 +04:00
|
|
|
folderMessage = tr( "Syncing Error." );
|
|
|
|
break;
|
|
|
|
case SyncResult::SetupError:
|
|
|
|
if ( overallResult.status() != SyncResult::Error ) {
|
2012-07-18 19:28:30 +04:00
|
|
|
overallResult.setStatus( SyncResult::SetupError );
|
2012-05-14 13:51:47 +04:00
|
|
|
}
|
|
|
|
folderMessage = tr( "Setup Error." );
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
folderMessage = tr( "Undefined Error State." );
|
2012-07-18 19:28:30 +04:00
|
|
|
overallResult.setStatus( SyncResult::Error );
|
2012-04-30 10:56:56 +04:00
|
|
|
}
|
2012-05-14 13:51:47 +04:00
|
|
|
} else {
|
2012-07-31 12:17:52 +04:00
|
|
|
// sync is disabled.
|
2012-05-15 20:03:53 +04:00
|
|
|
folderMessage = tr( "Sync is paused." );
|
2012-04-17 17:02:18 +04:00
|
|
|
}
|
|
|
|
}
|
2012-07-30 18:10:48 +04:00
|
|
|
qDebug() << "Folder in overallStatus Message: " << syncedFolder << " with name " << syncedFolder->alias();
|
|
|
|
QString msg = QString("Folder %1: %2").arg(syncedFolder->alias()).arg(folderMessage);
|
|
|
|
if( msg != _overallStatusStrings[syncedFolder->alias()] ) {
|
|
|
|
_overallStatusStrings[syncedFolder->alias()] = msg;
|
2012-05-14 13:51:47 +04:00
|
|
|
}
|
2011-10-13 18:41:24 +04:00
|
|
|
}
|
2012-03-23 18:31:46 +04:00
|
|
|
|
2012-07-18 19:28:30 +04:00
|
|
|
// create the tray blob message, check if we have an defined state
|
|
|
|
if( overallResult.status() != SyncResult::Undefined ) {
|
|
|
|
QStringList allStatusStrings = _overallStatusStrings.values();
|
|
|
|
if( ! allStatusStrings.isEmpty() )
|
|
|
|
trayMessage = allStatusStrings.join("\n");
|
|
|
|
else
|
|
|
|
trayMessage = tr("No sync folders configured.");
|
2012-04-17 17:02:18 +04:00
|
|
|
|
2012-07-18 19:28:30 +04:00
|
|
|
QIcon statusIcon = _theme->syncStateIcon( overallResult.status()); // size 48 before
|
2012-03-03 13:51:06 +04:00
|
|
|
|
2012-07-18 19:28:30 +04:00
|
|
|
_tray->setIcon( statusIcon );
|
|
|
|
_tray->setToolTip(trayMessage);
|
2012-04-17 17:02:18 +04:00
|
|
|
}
|
2011-12-12 20:47:30 +04:00
|
|
|
}
|
|
|
|
|
2012-06-15 15:36:38 +04:00
|
|
|
void Application::showHelp()
|
|
|
|
{
|
|
|
|
std::cout << _theme->appName().toLatin1().constData() << " version " <<
|
|
|
|
_theme->version().toLatin1().constData() << std::endl << std::endl;
|
|
|
|
std::cout << "File synchronisation desktop utility." << std::endl << std::endl;
|
|
|
|
std::cout << "Options:" << std::endl;
|
|
|
|
std::cout << " --logwindow : open a window to show log output." << std::endl;
|
|
|
|
std::cout << " --logfile <filename> : write log output to file <filename>." << std::endl;
|
|
|
|
std::cout << " --flushlog : flush the log file after every write." << std::endl;
|
|
|
|
std::cout << std::endl;
|
|
|
|
std::cout << "For more information, see http://www.owncloud.org" << std::endl;
|
|
|
|
_helpOnly = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool Application::giveHelp()
|
|
|
|
{
|
|
|
|
return _helpOnly;
|
|
|
|
}
|
2011-02-17 02:21:45 +03:00
|
|
|
} // namespace Mirall
|
|
|
|
|