/*

* Copyright (c) 2010-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <boost/signals2.hpp>

namespace Swift {

class AutoUpdater {

public:

virtual ~AutoUpdater();

virtual void checkForUpdates() = 0;

virtual bool recommendRestartToUpdate() = 0;

public:

/**

* Emit this signal if a new version of the software has been downloaded

* and the user needs to be notified so they can quit the app and start

* the newer version.

*/

boost::signals2::signal<void()> onSuggestRestartToUserToUpdate;

};

}

/*

* Copyright (c) 2010-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <memory>

#include <string>

#include <SwifTools/AutoUpdater/AutoUpdater.h>

namespace Swift {

/**

* @brief The SparkleAutoUpdater class provides integration with Sparkle.

* This enables automatic silent background updates. If using this in Qt you

* need to emit a NSApplicationWillTerminateNotification before you quit

* the application.

*/

class SparkleAutoUpdater : public AutoUpdater {

public:

~SparkleAutoUpdater();

void checkForUpdates();

bool recommendRestartToUpdate();

private:

class Private;

const std::unique_ptr<Private> d;

};

}

/*

* Copyright (c) 2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <SwifTools/AutoUpdater/SparkleAutoUpdater.h>

#include <Cocoa/Cocoa.h>

#include <Sparkle/Sparkle.h>

#include <SwifTools/AutoUpdater/SparkleAutoUpdaterDelegate.h>

#include <SwifTools/Cocoa/CocoaUtil.h>

namespace Swift {

class SparkleAutoUpdater::Private {

public:

SUUpdater* updater;

boost::intrusive_ptr<SparkleAutoUpdaterDelegate> delegate;

bool restartToUpdate = false;

};

d->updater = [SUUpdater sharedUpdater];

[d->updater retain];

d->delegate = boost::intrusive_ptr<SparkleAutoUpdaterDelegate>([[SparkleAutoUpdaterDelegate alloc] init], false);

[d->delegate.get() setUpdateDownloadFinished: [&](){

d->restartToUpdate = true;

onSuggestRestartToUserToUpdate();

}];

[d->updater setDelegate: d->delegate.get()];

[d->updater setAutomaticallyChecksForUpdates: true];

// Automatically check for an update after a day.

[d->updater setUpdateCheckInterval: 86400];

[d->updater setAutomaticallyDownloadsUpdates: true];

[d->updater setFeedURL: nsurl];

}

SparkleAutoUpdater::~SparkleAutoUpdater() {

[d->updater release];

}

void SparkleAutoUpdater::checkForUpdates() {

//[d->updater resetUpdateCycle]; // This is useful for testing to force a check ot start.

[d->updater checkForUpdatesInBackground];

}

bool SparkleAutoUpdater::recommendRestartToUpdate() {

return d->restartToUpdate;

}

}

/*

* Copyright (c) 2010-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Swift/QtUI/QtAboutWidget.h>

#include <QCoreApplication>

#include <QFile>

#include <QIcon>

#include <QLabel>

#include <QPushButton>

#include <QTextEdit>

#include <QTextStream>

#include <QVBoxLayout>

#include <QtGlobal>

#include <Swiften/Base/Log.h>

#include <Swiften/Base/Platform.h>

#include <Swift/QtUI/QtSwiftUtil.h>

namespace Swift {

#ifndef Q_OS_MAC

setWindowTitle(QString(tr("About %1")).arg("Swift"));

#endif

setWindowIcon(QIcon(":/logo-icon-16.png"));

resize(180, 240);

QVBoxLayout *mainLayout = new QVBoxLayout(this);

mainLayout->setAlignment(Qt::AlignHCenter);

setLayout(mainLayout);

QLabel* iconLabel = new QLabel(this);

iconLabel->setPixmap(QIcon(":/logo-shaded-text.256.png").pixmap(90, 90));

iconLabel->setAlignment(Qt::AlignHCenter);

mainLayout->addWidget(iconLabel);

QLabel* appNameLabel = new QLabel("<center><font size='+1'><b>" + QCoreApplication::applicationName() + "</b></font></center>", this);

mainLayout->addWidget(appNameLabel);

QLabel* versionLabel = new QLabel((QString("<center><font size='-1'>") + tr("Version %1") + "</font></center><center><font size='-1'><br/>" + QString(tr("Built with Qt %2")) + QString("<br/>") + QString(tr("Running with Qt %3")) + "</font></center>").arg(QCoreApplication::applicationVersion()).arg(QT_VERSION_STR).arg(qVersion()));

versionLabel->setTextInteractionFlags(Qt::TextSelectableByMouse | Qt::TextSelectableByKeyboard);

mainLayout->addWidget(versionLabel);

if (QCoreApplication::translate("TRANSLATION_INFO", "TRANSLATION_AUTHOR") != "TRANSLATION_AUTHOR") {

mainLayout->addWidget(new QLabel(QString("<center><font size='-1'>") + QString(tr("Using the English translation by\n%1")).arg(QCoreApplication::translate("TRANSLATION_INFO", "TRANSLATION_AUTHOR")).replace("\n", "<br/>") + "</font></center>", this));

}

QCoreApplication::translate("TRANSLATION_INFO", "TRANSLATION_LICENSE", "This string contains the license under which this translation is licensed. We ask you to license the translation under the BSD license. Please read http://www.opensource.org/licenses/bsd-license.php, and if you agree to release your translation under this license, use the following (untranslated) text: 'This translation is licensed under the BSD License. See http://www.opensource.org/licenses/bsd-license.php'");

#if defined(SWIFTEN_PLATFORM_WINDOWS) || defined(SWIFTEN_PLATFORM_MACOSX)

QPushButton* licenseButton = new QPushButton(tr("View License"), this);

mainLayout->addWidget(licenseButton);

connect(licenseButton, SIGNAL(clicked()), this, SLOT(handleLicenseClicked()));

QPushButton* changelogButton = new QPushButton(tr("View Changes"), this);

mainLayout->addWidget(changelogButton);

connect(changelogButton, SIGNAL(clicked()), this, SLOT(handleChangelogClicked()));

#else

// Some Linux desktops have dialog window decorations without close window buttons.

// This code adds a dedicated button to close the about window dialog.

QHBoxLayout* buttonLayout = new QHBoxLayout();

mainLayout->addLayout(buttonLayout);

QPushButton* licenseButton = new QPushButton(tr("View License"), this);

buttonLayout->addWidget(licenseButton);

connect(licenseButton, SIGNAL(clicked()), this, SLOT(handleLicenseClicked()));

QPushButton* changelogButton = new QPushButton(tr("View Changes"), this);

buttonLayout->addWidget(changelogButton);

connect(changelogButton, SIGNAL(clicked()), this, SLOT(handleChangelogClicked()));

buttonLayout->addItem(new QSpacerItem(20,20));

QPushButton* closeButton = new QPushButton(tr("Close"), this);

buttonLayout->addWidget(closeButton);

connect(closeButton, SIGNAL(clicked()), this, SLOT(accept()));

#endif

setFixedSize(minimumSizeHint());

}

void QtAboutWidget::handleLicenseClicked() {

openPlainTextWindow(":/COPYING");

}

void QtAboutWidget::handleChangelogClicked() {

openPlainTextWindow(":/ChangeLog.md");

}

void QtAboutWidget::openPlainTextWindow(const QString& path) {

QTextEdit* text = new QTextEdit();

text->setAttribute(Qt::WA_DeleteOnClose);

text->setReadOnly(true);

QFile file(path);

if (file.open(QIODevice::ReadOnly)) {

QTextStream in(&file);

in.setCodec("UTF-8");

text->setPlainText(in.readAll());

file.close();

text->resize(500, 600);

text->show();

text->activateWindow();

}

else {

SWIFT_LOG(error) << "Failed to open " << Q2PSTRING(path) << "." << std::endl;

}

}

}

/*

* Copyright (c) 2010-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <QDialog>

namespace Swift {

class QtAboutWidget : public QDialog {

Q_OBJECT

public:

private slots:

void handleLicenseClicked();

void handleChangelogClicked();

private:

void openPlainTextWindow(const QString& path);

};

}

} else {

onCancelLoginRequest();

}

}

void QtLoginWindow::setLoginAutomatically(bool loginAutomatically) {

loginAutomatically_->setChecked(loginAutomatically);

}

void QtLoginWindow::handleCertficateChecked(bool checked) {

if (checked) {

#ifdef HAVE_SCHANNEL

certificateFile_ = P2QSTRING(selectCAPICertificate());

if (certificateFile_.isEmpty()) {

certificateButton_->setChecked(false);

}

#else

certificateFile_ = QFileDialog::getOpenFileName(this, tr("Select an authentication certificate"), QString(), tr("P12 files (*.cert *.p12 *.pfx);;All files (*.*)"));

if (certificateFile_.isEmpty()) {

certificateButton_->setChecked(false);

}

#endif

}

else {

certificateFile_ = "";

}

}

void QtLoginWindow::handleAbout() {

if (!aboutDialog_) {

aboutDialog_->show();

}

else {

aboutDialog_->show();

aboutDialog_->raise();

aboutDialog_->activateWindow();

}

}

void QtLoginWindow::handleShowXMLConsole() {

uiEventStream_->send(std::make_shared<RequestXMLConsoleUIEvent>());

}

void QtLoginWindow::handleShowFileTransferOverview() {

uiEventStream_->send(std::make_shared<RequestFileTransferListUIEvent>());

}

void QtLoginWindow::handleShowHighlightEditor() {

uiEventStream_->send(std::make_shared<RequestHighlightEditorUIEvent>());

}

void QtLoginWindow::handleToggleSounds(bool enabled) {

settings_->storeSetting(SettingConstants::PLAY_SOUNDS, enabled);

}

void QtLoginWindow::handleToggleNotifications(bool enabled) {

settings_->storeSetting(SettingConstants::SHOW_NOTIFICATIONS, enabled);

}

void QtLoginWindow::handleQuit() {

#include <Swiften/Base/Platform.h>

#include <Swiften/Client/Client.h>

#include <Swiften/Elements/Presence.h>

#include <Swiften/TLS/TLSContextFactory.h>

#include <SwifTools/Application/PlatformApplicationPathProvider.h>

#include <SwifTools/AutoUpdater/AutoUpdater.h>

#include <SwifTools/AutoUpdater/PlatformAutoUpdaterFactory.h>

#include <Swift/Controllers/ApplicationInfo.h>

#include <Swift/Controllers/BuildVersion.h>

#include <Swift/Controllers/MainController.h>

#include <Swift/Controllers/SettingConstants.h>

#include <Swift/Controllers/Settings/SettingsProviderHierachy.h>

#include <Swift/Controllers/Settings/XMLSettingsProvider.h>

#include <Swift/Controllers/StatusCache.h>

#include <Swift/Controllers/Storages/CertificateFileStorageFactory.h>

#include <Swift/Controllers/Storages/FileStoragesFactory.h>

#include <Swift/QtUI/QtChatTabs.h>

#include <Swift/QtUI/QtChatTabsBase.h>

#include <Swift/QtUI/QtChatTabsShortcutOnlySubstitute.h>

#include <Swift/QtUI/QtChatWindowFactory.h>

#include <Swift/QtUI/QtLoginWindow.h>

#include <Swift/QtUI/QtSingleWindow.h>

#include <Swift/QtUI/QtSoundPlayer.h>

#include <Swift/QtUI/QtSwiftUtil.h>

#include <Swift/QtUI/QtSystemTray.h>

#include <Swift/QtUI/QtUIFactory.h>

#include <Swift/QtUI/QtUISettingConstants.h>

#if defined(SWIFTEN_PLATFORM_WINDOWS)

#include <Swift/QtUI/WindowsNotifier.h>

#elif defined(HAVE_GROWL)

#include <SwifTools/Notifier/GrowlNotifier.h>

#elif defined(SWIFTEN_PLATFORM_LINUX)

#include <Swift/QtUI/FreeDesktopNotifier.h>

#elif defined(SWIFTEN_PLATFORM_MACOSX)

#include <SwifTools/Notifier/NotificationCenterNotifier.h>

#else

#include <SwifTools/Notifier/NullNotifier.h>

#endif

#if defined(SWIFTEN_PLATFORM_MACOSX)

#include <SwifTools/Dock/MacOSXDock.h>

#else

#include <SwifTools/Dock/NullDock.h>

#endif

#if defined(SWIFTEN_PLATFORM_MACOSX)

#include <Swift/QtUI/QtURIHandler.h>

#elif defined(SWIFTEN_PLATFORM_WIN32)

#include <SwifTools/URIHandler/NullURIHandler.h>

#else

#include <Swift/QtUI/QtDBUSURIHandler.h>

#endif

#if defined(SWIFTEN_PLATFORM_MACOSX)

#include <Swift/QtUI/CocoaUIHelpers.h>

#endif

namespace Swift{

po::options_description QtSwift::getOptionsDescription() {

po::options_description result("Options");

result.add_options()

("debug", "Turn on debug logging")

("help", "Show this help message")

("version", "Show version information")

("netbook-mode", "Use netbook mode display (unsupported)")

("no-tabs", "Don't manage chat windows in tabs (unsupported)")

("latency-debug", "Use latency debugging (unsupported)")

("multi-account", po::value<int>()->default_value(1), "Number of accounts to open windows for (unsupported)")

("start-minimized", "Don't show the login/roster window at startup")

("enable-jid-adhocs", "Enable AdHoc commands to custom JID's.")

#if QT_VERSION >= 0x040800

("language", po::value<std::string>(), "Use a specific language, instead of the system-wide one")

#endif

;

return result;

}

XMLSettingsProvider* QtSwift::loadSettingsFile(const QString& fileName) {

QFile configFile(fileName);

if (configFile.exists() && configFile.open(QIODevice::ReadOnly)) {

QString xmlString;

while (!configFile.atEnd()) {

QByteArray line = configFile.readLine();

xmlString += line + "\n";

}

return new XMLSettingsProvider(Q2PSTRING(xmlString));

}

return new XMLSettingsProvider("");

}

void QtSwift::loadEmoticonsFile(const QString& fileName, std::map<std::string, std::string>& emoticons) {

QFile file(fileName);

if (file.exists() && file.open(QIODevice::ReadOnly)) {

while (!file.atEnd()) {

QString line = file.readLine();

line.replace("\n", "");

line.replace("\r", "");

QStringList tokens = line.split(" ");

if (tokens.size() == 2) {

QString emoticonFile = tokens[1];

if (!emoticonFile.startsWith(":/") && !emoticonFile.startsWith("qrc:/")) {

emoticonFile = "file://" + emoticonFile;

}

emoticons[Q2PSTRING(tokens[0])] = Q2PSTRING(emoticonFile);

}

}

}

}

QtSwift::QtSwift(const po::variables_map& options) : networkFactories_(&clientMainThreadCaller_), autoUpdater_(nullptr), idleDetector_(&idleQuerier_, networkFactories_.getTimerFactory(), 1000) {

QCoreApplication::setApplicationName(SWIFT_APPLICATION_NAME);

QCoreApplication::setOrganizationName(SWIFT_ORGANIZATION_NAME);

QCoreApplication::setOrganizationDomain(SWIFT_ORGANIZATION_DOMAIN);

QCoreApplication::setApplicationVersion(buildVersion);

qtSettings_ = new QtSettingsProvider();

xmlSettings_ = loadSettingsFile(P2QSTRING(pathToString(Paths::getExecutablePath() / "system-settings.xml")));

settingsHierachy_ = new SettingsProviderHierachy();

settingsHierachy_->addProviderToTopOfStack(xmlSettings_);

settingsHierachy_->addProviderToTopOfStack(qtSettings_);

networkFactories_.getTLSContextFactory()->setDisconnectOnCardRemoval(settingsHierachy_->getSetting(SettingConstants::DISCONNECT_ON_CARD_REMOVAL));

std::map<std::string, std::string> emoticons;

loadEmoticonsFile(":/emoticons/emoticons.txt", emoticons);

loadEmoticonsFile(P2QSTRING(pathToString(Paths::getExecutablePath() / "emoticons.txt")), emoticons);

if (options.count("netbook-mode")) {

splitter_ = new QtSingleWindow(qtSettings_);

} else {

splitter_ = nullptr;

}

int numberOfAccounts = 1;

try {

numberOfAccounts = options["multi-account"].as<int>();

} catch (...) {

/* This seems to fail on a Mac when the .app is launched directly (the usual path).*/

numberOfAccounts = 1;

}

for (int i = 0; i < numberOfAccounts; i++) {

if (i > 0) {

// Don't add the first tray (see note above)

systemTrays_.push_back(new QtSystemTray());

}

QtUIFactory* uiFactory = new QtUIFactory(settingsHierachy_, qtSettings_, tabs_, splitter_, systemTrays_[i], chatWindowFactory_, networkFactories_.getTimerFactory(), statusCache_, startMinimized, !emoticons.empty(), enableAdHocCommandOnJID);

uiFactories_.push_back(uiFactory);

MainController* mainController = new MainController(

&clientMainThreadCaller_,

&networkFactories_,

uiFactory,

settingsHierachy_,

systemTrays_[i],

soundPlayer_,

storagesFactory_,

certificateStorageFactory_,

dock_,

notifier_,

uriHandler_,

&idleDetector_,

emoticons,

options.count("latency-debug") > 0);

mainControllers_.push_back(mainController);

}

connect(qApp, SIGNAL(aboutToQuit()), this, SLOT(handleAboutToQuit()));

PlatformAutoUpdaterFactory autoUpdaterFactory;

autoUpdater_->checkForUpdates();

autoUpdater_->onSuggestRestartToUserToUpdate.connect(boost::bind(&QtSwift::handleRecommendRestartToInstallUpdate, this));

}

}

QtSwift::~QtSwift() {

delete autoUpdater_;

for (auto* factory : uiFactories_) {

delete factory;

}

for (auto* controller : mainControllers_) {

delete controller;

}

delete notifier_;

for (auto* tray : systemTrays_) {

delete tray;

}

delete tabs_;

delete splitter_;

delete settingsHierachy_;

delete qtSettings_;

delete xmlSettings_;

delete statusCache_;

delete uriHandler_;

delete dock_;

delete soundPlayer_;

delete chatWindowFactory_;

delete certificateStorageFactory_;

delete storagesFactory_;

delete applicationPathProvider_;

}

void QtSwift::handleAboutToQuit() {

#if defined(SWIFTEN_PLATFORM_MACOSX)

// This is required so Sparkle knows about the application shutting down

// and can update the application in background.

CocoaUIHelpers::sendCocoaApplicationWillTerminateNotification();

#endif

}

void QtSwift::handleRecommendRestartToInstallUpdate() {

}

}

class AvatarStorage;

class CapsStorage;

class MainController;

class QtSystemTray;

class QtChatTabsBase;

class QtChatWindowFactory;

class QtSoundPlayer;

class QtMUCSearchWindowFactory;

class QtUserSearchWindowFactory;

class EventLoop;

class URIHandler;

class SettingsProviderHierachy;

class XMLSettingsProvider;

class StatusCache;

class QtSingleWindow;

class QtSwift : public QObject {

Q_OBJECT

public:

QtSwift(const po::variables_map& options);

static po::options_description getOptionsDescription();

~QtSwift();

private slots:

void handleAboutToQuit();

void handleRecommendRestartToInstallUpdate();

private:

XMLSettingsProvider* loadSettingsFile(const QString& fileName);

void loadEmoticonsFile(const QString& fileName, std::map<std::string, std::string>& emoticons);

private:

QtEventLoop clientMainThreadCaller_;

PlatformTLSFactories tlsFactories_;

BoostNetworkFactories networkFactories_;

QtChatWindowFactory* chatWindowFactory_;

std::vector<MainController*> mainControllers_;

std::vector<QtSystemTray*> systemTrays_;

std::vector<QtUIFactory*> uiFactories_;

QtSettingsProvider* qtSettings_;

XMLSettingsProvider* xmlSettings_;

SettingsProviderHierachy* settingsHierachy_;

QtSingleWindow* splitter_;

QtSoundPlayer* soundPlayer_;

Dock* dock_;

URIHandler* uriHandler_;

QtChatTabsBase* tabs_;

ApplicationPathProvider* applicationPathProvider_;

StoragesFactory* storagesFactory_;

CertificateStorageFactory* certificateStorageFactory_;

AutoUpdater* autoUpdater_;

Notifier* notifier_;

StatusCache* statusCache_;

PlatformIdleQuerier idleQuerier_;

ActualIdleDetector idleDetector_;

#if defined(SWIFTEN_PLATFORM_MACOSX)

CocoaApplication cocoaApplication_;

CocoaApplicationActivateHelper cocoaApplicationActivateHelper_;

#endif

};

/*

* Copyright (c) 2012-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Swift/QtUI/QtUISettingConstants.h>

namespace Swift {

const SettingsProvider::Setting<bool> QtUISettingConstants::COMPACT_ROSTER("compactRoster", false);

const SettingsProvider::Setting<std::string> QtUISettingConstants::CLICKTHROUGH_BANNER("clickthroughBanner", "");

const SettingsProvider::Setting<int> QtUISettingConstants::CURRENT_ROSTER_TAB("currentRosterTab", 0);

const SettingsProvider::Setting<bool> QtUISettingConstants::SHOW_NICK_IN_ROSTER_HEADER("showNickInRosterHeader", true);

const SettingsProvider::Setting<int> QtUISettingConstants::CHATWINDOW_FONT_SIZE("chatWindowFontSize", 0);

const SettingsProvider::Setting<int> QtUISettingConstants::HISTORYWINDOW_FONT_SIZE("historyWindowFontSize", 0);

const SettingsProvider::Setting<bool> QtUISettingConstants::SHOW_EMOTICONS("showEmoticons", true);

const SettingsProvider::Setting<bool> QtUISettingConstants::USE_PLAIN_CHATS("plainChats", false);

const SettingsProvider::Setting<bool> QtUISettingConstants::USE_SCREENREADER("screenreader", false);

const SettingsProvider::Setting<bool> QtUISettingConstants::SPELL_CHECKER("spellChecker", false);

const SettingsProvider::Setting<std::string> QtUISettingConstants::SPELL_CHECKER_LANGUAGE("spellCheckerLanguage", "en_US");

const SettingsProvider::Setting<std::string> QtUISettingConstants::TRELLIS_GRID_SIZE("trellisGridSize", "");

const SettingsProvider::Setting<std::string> QtUISettingConstants::TRELLIS_GRID_POSITIONS("trellisGridPositions", "");

const SettingsProvider::Setting<bool> QtUISettingConstants::ENABLE_SOFTWARE_UPDATES("enableSoftwareUpdates", true);

}

/*

* Copyright (c) 2012-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swift/Controllers/Settings/SettingsProvider.h>

namespace Swift {

class QtUISettingConstants {

public:

static const SettingsProvider::Setting<bool> COMPACT_ROSTER;

static const SettingsProvider::Setting<std::string> CLICKTHROUGH_BANNER;

static const SettingsProvider::Setting<int> CURRENT_ROSTER_TAB;

static const SettingsProvider::Setting<bool> SHOW_NICK_IN_ROSTER_HEADER;

static const SettingsProvider::Setting<int> CHATWINDOW_FONT_SIZE;

static const SettingsProvider::Setting<int> HISTORYWINDOW_FONT_SIZE;

static const SettingsProvider::Setting<bool> SHOW_EMOTICONS;

static const SettingsProvider::Setting<bool> USE_PLAIN_CHATS;

static const SettingsProvider::Setting<bool> USE_SCREENREADER;

static const SettingsProvider::Setting<bool> SPELL_CHECKER;

static const SettingsProvider::Setting<std::string> SPELL_CHECKER_LANGUAGE;

/**

* The #TRELLIS_GRID_SIZE setting specifies the dimensions of the grid used for the trellis

* layout.

*

* Its value is a Qt serialized representation.

*/

static const SettingsProvider::Setting<std::string> TRELLIS_GRID_SIZE;

/**

* The #TRELLIS_GRID_POSITIONS setting specifies where conversations to contacts or rooms go

* in the trellis grid.

*

* Its value is a Qt serialized representation.

*/

static const SettingsProvider::Setting<std::string> TRELLIS_GRID_POSITIONS;

/**

* should automatically check for software updates in regular

* intervals and install them automatically.

*/

static const SettingsProvider::Setting<bool> ENABLE_SOFTWARE_UPDATES;

};

}

"MUCSearch/QtMUCSearchWindow.cpp",

"UserSearch/ContactListDelegate.cpp",

"UserSearch/ContactListModel.cpp",

"UserSearch/QtContactListWidget.cpp",

"UserSearch/QtSuggestingJIDInput.cpp",

"UserSearch/QtUserSearchFirstPage.cpp",

"UserSearch/QtUserSearchFirstMultiJIDPage.cpp",

"UserSearch/QtUserSearchFieldsPage.cpp",

"UserSearch/QtUserSearchResultsPage.cpp",

"UserSearch/QtUserSearchDetailsPage.cpp",

"UserSearch/QtUserSearchWindow.cpp",

"UserSearch/UserSearchModel.cpp",

"UserSearch/UserSearchDelegate.cpp",

"Whiteboard/FreehandLineItem.cpp",

"Whiteboard/GView.cpp",

"Whiteboard/TextDialog.cpp",

"Whiteboard/QtWhiteboardWindow.cpp",

"Whiteboard/ColorWidget.cpp",

"QtSubscriptionRequestWindow.cpp",

"QtRosterHeader.cpp",

"QtWebView.cpp",

"qrc_DefaultTheme.cc",

"qrc_Swift.cc",

"QtChatWindowJSBridge.cpp",

"QtMUCConfigurationWindow.cpp",

"QtAffiliationEditor.cpp",

"QtUISettingConstants.cpp",

"QtURLValidator.cpp",

"QtResourceHelper.cpp",

"QtSpellCheckHighlighter.cpp",

"Trellis/QtDynamicGridLayout.cpp",

"Trellis/QtDNDTabBar.cpp",

"Trellis/QtGridSelectionDialog.cpp"

]

if env["PLATFORM"] == "win32" :

sources.extend(["qrc_SwiftWindows.cc"])

# QtVCardWidget

sources.extend([

"QtVCardWidget/QtCloseButton.cpp",

"QtVCardWidget/QtRemovableItemDelegate.cpp",

"QtVCardWidget/QtResizableLineEdit.cpp",

"QtVCardWidget/QtTagComboBox.cpp",

"QtVCardWidget/QtVCardHomeWork.cpp",

"QtVCardWidget/QtVCardAddressField.cpp",

"QtVCardWidget/QtVCardAddressLabelField.cpp",

"QtVCardWidget/QtVCardBirthdayField.cpp",

"QtVCardWidget/QtVCardDescriptionField.cpp",

"QtVCardWidget/QtVCardInternetEMailField.cpp",

"QtVCardWidget/QtVCardJIDField.cpp",

"QtVCardWidget/QtVCardOrganizationField.cpp",

"QtVCardWidget/QtVCardPhotoAndNameFields.cpp",

"QtVCardWidget/QtVCardRoleField.cpp",

"QtVCardWidget/QtVCardTelephoneField.cpp",

"QtVCardWidget/QtVCardTitleField.cpp",

"QtVCardWidget/QtVCardURLField.cpp",

"QtVCardWidget/QtVCardGeneralField.cpp",

"QtVCardWidget/QtVCardWidget.cpp"

])

if env["PLATFORM"] == "darwin" :

sources += ["CocoaApplicationActivateHelper.mm"]

sources += ["CocoaUIHelpers.mm"]

if env["PLATFORM"] == "darwin" or env["PLATFORM"] == "win32" :

swiftProgram = myenv.Program("Swift", sources)

else :

sources += ["QtCertificateViewerDialog.cpp"];

myenv.Uic4("QtCertificateViewerDialog.ui");

swiftProgram = myenv.Program("swift-im", sources)

if env["PLATFORM"] != "darwin" and env["PLATFORM"] != "win32" :

openURIProgram = myenv.Program("swift-open-uri", "swift-open-uri.cpp")

else :

openURIProgram = []

myenv.Uic4("MUCSearch/QtMUCSearchWindow.ui")

myenv.Uic4("UserSearch/QtUserSearchWizard.ui")

myenv.Uic4("UserSearch/QtUserSearchFirstPage.ui")

myenv.Uic4("UserSearch/QtUserSearchFirstMultiJIDPage.ui")

myenv.Uic4("UserSearch/QtUserSearchFieldsPage.ui")

myenv.Uic4("UserSearch/QtUserSearchResultsPage.ui")

myenv.Uic4("QtBookmarkDetailWindow.ui")

myenv.Uic4("QtAffiliationEditor.ui")

myenv.Uic4("QtJoinMUCWindow.ui")

myenv.Uic4("QtHistoryWindow.ui")

myenv.Uic4("QtConnectionSettings.ui")

myenv.Uic4("QtHighlightEditor.ui")

myenv.Uic4("QtBlockListEditorWindow.ui")

myenv.Uic4("QtSpellCheckerWindow.ui")

myenv.Qrc("DefaultTheme.qrc")

myenv.Qrc("Swift.qrc")

if env["PLATFORM"] == "win32" :

myenv.Qrc("SwiftWindows.qrc")

# Resources

commonResources = {

"": ["#/Swift/resources/sounds"]

}

myenv["TEXTFILESUFFIX"] = ""

myenv.MyTextfile(target = "COPYING", source = [myenv.File("../../COPYING.gpl"), myenv.File("../../COPYING.thirdparty")], LINESEPARATOR = "\n\n========\n\n\n")

################################################################################

# Translation

################################################################################

# Collect available languages

translation_languages = []

for file in os.listdir(Dir("#/Swift/Translations").abspath) :

if file.startswith("swift_") and file.endswith(".ts") :

translation_languages.append(file[6:-3])

# Generate translation modules

translation_sources = [env.File("#/Swift/Translations/swift.ts").abspath]

translation_modules = []

for lang in translation_languages :

translation_resource = "#/Swift/resources/translations/swift_" + lang + ".qm"

translation_source = "#/Swift/Translations/swift_" + lang + ".ts"