notifier_ = new TogglableNotifier(notifier);

notifier_->setPersistentEnabled(settings_->getSetting(SettingConstants::SHOW_NOTIFICATIONS));

eventController_ = new EventController();

eventController_->onEventQueueLengthChange.connect(boost::bind(&MainController::handleEventQueueLengthChange, this, _1));

systemTrayController_ = new SystemTrayController(eventController_, systemTray);

loginWindow_ = uiFactory_->createLoginWindow(uiEventStream_);

loginWindow_->setShowNotificationToggle(!notifier->isExternallyConfigured());

soundEventController_ = new SoundEventController(eventController_, soundPlayer, settings);

xmppURIController_ = new XMPPURIController(uriHandler_, uiEventStream_);

std::string selectedLoginJID = settings_->getSetting(SettingConstants::LAST_LOGIN_JID);

bool loginAutomatically = settings_->getSetting(SettingConstants::LOGIN_AUTOMATICALLY);

std::string cachedPassword;

std::string cachedCertificate;

bool eagle = settings_->getSetting(SettingConstants::FORGET_PASSWORDS);

if (!eagle) {

foreach (std::string profile, settings->getAvailableProfiles()) {

ProfileSettingsProvider profileSettings(profile, settings);

std::string password = profileSettings.getStringSetting("pass");

std::string certificate = profileSettings.getStringSetting("certificate");

std::string jid = profileSettings.getStringSetting("jid");

loginWindow_->addAvailableAccount(jid, password, certificate);

if (jid == selectedLoginJID) {

cachedPassword = password;

cachedCertificate = certificate;

}

}

loginWindow_->selectUser(selectedLoginJID);

loginWindow_->setLoginAutomatically(loginAutomatically);

}

loginWindow_->onPurgeSavedLoginRequest.connect(boost::bind(&MainController::handlePurgeSavedLoginRequest, this, _1));

loginWindow_->onCancelLoginRequest.connect(boost::bind(&MainController::handleCancelLoginRequest, this));

loginWindow_->onQuitRequest.connect(boost::bind(&MainController::handleQuitRequest, this));

idleDetector_->setIdleTimeSeconds(settings->getSetting(SettingConstants::IDLE_TIMEOUT));

idleDetector_->onIdleChanged.connect(boost::bind(&MainController::handleInputIdleChanged, this, _1));

xmlConsoleController_ = new XMLConsoleController(uiEventStream_, uiFactory_);

fileTransferListController_ = new FileTransferListController(uiEventStream_, uiFactory_);

settings_->onSettingChanged.connect(boost::bind(&MainController::handleSettingChanged, this, _1));

if (loginAutomatically) {

profileSettings_ = new ProfileSettingsProvider(selectedLoginJID, settings_);

} else {

profileSettings_ = NULL;

}

}

MainController::~MainController() {

idleDetector_->onIdleChanged.disconnect(boost::bind(&MainController::handleInputIdleChanged, this, _1));

purgeCachedCredentials();

//setManagersOffline();

eventController_->disconnectAll();

resetClient();

delete fileTransferListController_;

delete xmlConsoleController_;

delete xmppURIController_;

delete soundEventController_;

delete systemTrayController_;

delete eventController_;

delete notifier_;

delete uiEventStream_;

}

void MainController::purgeCachedCredentials() {

safeClear(password_);

}

void MainController::resetClient() {

purgeCachedCredentials();

resetCurrentError();

resetPendingReconnects();

vCardPhotoHash_.clear();

delete contactEditController_;

contactEditController_ = NULL;

delete profileController_;

}

client_->getPresenceSender()->sendPresence(presence);

if (presence->getType() == Presence::Unavailable) {

logout();

}

}

void MainController::handleInputIdleChanged(bool idle) {

if (!statusTracker_) {

//Haven't logged in yet.

return;

}

if (settings_->getSetting(SettingConstants::IDLE_GOES_OFFLINE)) {

if (idle) {

logout();

}

}

else {

if (idle) {

if (statusTracker_->goAutoAway()) {

if (client_ && client_->isAvailable()) {

sendPresence(statusTracker_->getNextPresence());

}

}

} else {

if (statusTracker_->goAutoUnAway()) {

if (client_ && client_->isAvailable()) {

sendPresence(statusTracker_->getNextPresence());

}

}

}

}

}

jid_ = JID(username);

if (!jid_.isValid() || jid_.getNode().empty()) {

loginWindow_->setMessage(QT_TRANSLATE_NOOP("", "User address invalid. User address should be of the form 'alice@wonderland.lit'"));

loginWindow_->setIsLoggingIn(false);

} else {

loginWindow_->setMessage("");

loginWindow_->setIsLoggingIn(true);

profileSettings_ = new ProfileSettingsProvider(username, settings_);

if (!settings_->getSetting(SettingConstants::FORGET_PASSWORDS)) {

profileSettings_->storeString("jid", username);

profileSettings_->storeString("pass", (remember || loginAutomatically) ? password : "");

settings_->storeSetting(SettingConstants::LAST_LOGIN_JID, username);

settings_->storeSetting(SettingConstants::LOGIN_AUTOMATICALLY, loginAutomatically);

loginWindow_->addAvailableAccount(profileSettings_->getStringSetting("jid"), profileSettings_->getStringSetting("pass"), profileSettings_->getStringSetting("certificate"));

}

password_ = password;

performLoginFromCachedCredentials();

}

}

void MainController::handlePurgeSavedLoginRequest(const std::string& username) {

settings_->removeProfile(username);

loginWindow_->removeAvailableAccount(username);

}

void MainController::performLoginFromCachedCredentials() {

if (settings_->getSetting(SettingConstants::FORGET_PASSWORDS) && password_.empty()) {

/* Then we can't try to login again. */

return;

}

/* If we logged in with a bare JID, and we have a full bound JID, re-login with the

* bound JID to try and keep dynamically assigned resources */

JID clientJID = jid_;

if (boundJID_.isValid() && jid_.isBare() && boundJID_.toBare() == jid_) {

clientJID = boundJID_;

}

if (!statusTracker_) {

statusTracker_ = new StatusTracker();

}

if (!clientInitialized_) {

storages_ = storagesFactory_->createStorages(jid_.toBare());

certificateStorage_ = certificateStorageFactory_->createCertificateStorage(jid_.toBare());

certificateTrustChecker_ = new CertificateStorageTrustChecker(certificateStorage_);

client_ = boost::make_shared<Swift::Client>(clientJID, createSafeByteArray(password_.c_str()), networkFactories_, storages_);

clientInitialized_ = true;

client_->setCertificateTrustChecker(certificateTrustChecker_);

client_->onDataRead.connect(boost::bind(&XMLConsoleController::handleDataRead, xmlConsoleController_, _1));

client_->onDataWritten.connect(boost::bind(&XMLConsoleController::handleDataWritten, xmlConsoleController_, _1));

client_->onDisconnected.connect(boost::bind(&MainController::handleDisconnected, this, _1));

client_->onConnected.connect(boost::bind(&MainController::handleConnected, this));

client_->setSoftwareVersion(CLIENT_NAME, buildVersion);

client_->getVCardManager()->onVCardChanged.connect(boost::bind(&MainController::handleVCardReceived, this, _1, _2));

presenceNotifier_ = new PresenceNotifier(client_->getStanzaChannel(), notifier_, client_->getMUCRegistry(), client_->getAvatarManager(), client_->getNickResolver(), client_->getPresenceOracle(), networkFactories_->getTimerFactory());

presenceNotifier_->onNotificationActivated.connect(boost::bind(&MainController::handleNotificationClicked, this, _1));

eventNotifier_ = new EventNotifier(eventController_, notifier_, client_->getAvatarManager(), client_->getNickResolver());

eventNotifier_->onNotificationActivated.connect(boost::bind(&MainController::handleNotificationClicked, this, _1));

}

boost::shared_ptr<Presence> presence(new Presence());

presence->setShow(static_cast<StatusShow::Type>(profileSettings_->getIntSetting("lastShow", StatusShow::Online)));

presence->setStatus(profileSettings_->getStringSetting("lastStatus"));

statusTracker_->setRequestedPresence(presence);

} else {

/* In case we're in the middle of another login, make sure they don't overlap */

client_->disconnect();

}

systemTrayController_->setConnecting();

if (rosterController_) {

rosterController_->getWindow()->setConnecting();

}

ClientOptions clientOptions;

bool eagle = settings_->getSetting(SettingConstants::FORGET_PASSWORDS);

clientOptions.forgetPassword = eagle;

clientOptions.useTLS = eagle ? ClientOptions::RequireTLS : ClientOptions::UseTLSWhenAvailable;

/*if (clientJID.getDomain() == "doomsong.co.uk") {

clientOptions.boshURL = URL("https", "channels.doomsong.co.uk", 11443, "http-bind/");

clientOptions.boshHTTPConnectProxyURL = URL("http", "squidproxy.doomsong.co.uk", 8123, "");

}*/

client_->connect(clientOptions);

}

void MainController::handleDisconnected(const boost::optional<ClientError>& error) {

if (settings_->getSetting(SettingConstants::FORGET_PASSWORDS)) {

purgeCachedCredentials();

}

if (quitRequested_) {

resetClient();

loginWindow_->quit();

}

else if (error) {

std::string message;

std::string certificateErrorMessage;

class MUCSearchController;

class UserSearchController;

class StatusTracker;

class Dock;

class Storages;

class StoragesFactory;

class NetworkFactories;

class URIHandler;

class XMPPURIController;

class AdHocManager;

class AdHocCommandWindowFactory;

class FileTransferOverview;

class MainController {

public:

MainController(

EventLoop* eventLoop,

NetworkFactories* networkFactories,

UIFactory* uiFactories,

SettingsProvider *settings,

SystemTray* systemTray,

SoundPlayer* soundPlayer,

StoragesFactory* storagesFactory,

CertificateStorageFactory* certificateStorageFactory,

Dock* dock,

Notifier* notifier,

URIHandler* uriHandler,

IdleDetector* idleDetector,

bool useDelayForLatency);

~MainController();

private:

void resetClient();

void handleConnected();

void handleCancelLoginRequest();

void handleQuitRequest();

void handleChangeStatusRequest(StatusShow::Type show, const std::string &statusText);

void handleDisconnected(const boost::optional<ClientError>& error);

void handleServerDiscoInfoResponse(boost::shared_ptr<DiscoInfo>, ErrorPayload::ref);

void handleEventQueueLengthChange(int count);

void handleVCardReceived(const JID& j, VCard::ref vCard);

void handleSettingChanged(const std::string& settingPath);

void handlePurgeSavedLoginRequest(const std::string& username);

void sendPresence(boost::shared_ptr<Presence> presence);

void handleInputIdleChanged(bool);

void logout();

void signOut();

void setReconnectTimer();

void resetPendingReconnects();

void resetCurrentError();

void performLoginFromCachedCredentials();

void reconnectAfterError();

void setManagersOffline();

void handleNotificationClicked(const JID& jid);

void handleForceQuit();

void purgeCachedCredentials();

private:

EventLoop* eventLoop_;

NetworkFactories* networkFactories_;

UIFactory* uiFactory_;

StoragesFactory* storagesFactory_;

Storages* storages_;

CertificateStorageFactory* certificateStorageFactory_;

CertificateStorage* certificateStorage_;

CertificateStorageTrustChecker* certificateTrustChecker_;

bool clientInitialized_;

boost::shared_ptr<Client> client_;

SettingsProvider *settings_;

ProfileSettingsProvider* profileSettings_;

Dock* dock_;

URIHandler* uriHandler_;

IdleDetector* idleDetector_;

TogglableNotifier* notifier_;

PresenceNotifier* presenceNotifier_;

EventNotifier* eventNotifier_;

RosterController* rosterController_;

EventController* eventController_;

EventWindowController* eventWindowController_;

AdHocManager* adHocManager_;

LoginWindow* loginWindow_;

UIEventStream* uiEventStream_;

XMLConsoleController* xmlConsoleController_;

FileTransferListController* fileTransferListController_;

ChatsManager* chatsManager_;

ProfileController* profileController_;

ContactEditController* contactEditController_;

JID jid_;

JID boundJID_;

SystemTrayController* systemTrayController_;

SoundEventController* soundEventController_;

XMPPURIController* xmppURIController_;

std::string vCardPhotoHash_;

std::string password_;

boost::shared_ptr<ErrorEvent> lastDisconnectError_;

bool useDelayForLatency_;

UserSearchController* userSearchControllerChat_;

UserSearchController* userSearchControllerAdd_;

int timeBeforeNextReconnect_;

Timer::ref reconnectTimer_;

StatusTracker* statusTracker_;

bool myStatusLooksOnline_;

bool quitRequested_;

bool offlineRequested_;

static const int SecondsToWaitBeforeForceQuitting;

FileTransferOverview* ftOverview_;

};

}

/*

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#pragma once

#include <boost/shared_ptr.hpp>

#include <string>

#include <Swiften/TLS/Certificate.h>

namespace Swift {

class MainWindow;

class LoginWindow {

public:

virtual ~LoginWindow() {};

virtual void selectUser(const std::string&) = 0;

virtual void morphInto(MainWindow *mainWindow) = 0;

virtual void loggedOut() = 0;

virtual void setShowNotificationToggle(bool) = 0;

virtual void setMessage(const std::string&) = 0;

virtual void setIsLoggingIn(bool loggingIn) = 0;

virtual void addAvailableAccount(const std::string& defaultJID, const std::string& defaultPassword, const std::string& defaultCertificate) = 0;

virtual void removeAvailableAccount(const std::string& jid) = 0;

virtual void setLoginAutomatically(bool loginAutomatically) = 0;

virtual void quit() = 0;

/** Blocking request whether a cert should be permanently trusted.*/

virtual bool askUserToTrustCertificatePermanently(const std::string& message, Certificate::ref) = 0;

boost::signal<void ()> onCancelLoginRequest;

boost::signal<void ()> onQuitRequest;

boost::signal<void (const std::string&)> onPurgeSavedLoginRequest;

};

}

/*

* Copyright (c) 2012 Isode Limited, London, England.

* Licensed under the simplified BSD license.

* See Documentation/Licenses/BSD-simplified.txt for more information.

*/

#include <string>

#define SECURITY_WIN32

#include <Windows.h>

#include <WinCrypt.h>

#include <cryptuiapi.h>

namespace Swift {

#define cert_dlg_title L"TLS Client Certificate Selection"

#define cert_dlg_prompt L"Select a certificate to use for authentication"

/////Hmm, maybe we should not exlude the "location" column

#define exclude_columns CRYPTUI_SELECT_LOCATION_COLUMN \

|CRYPTUI_SELECT_INTENDEDUSE_COLUMN

static std::string getCertUri(PCCERT_CONTEXT cert, const char * cert_store_name) {

DWORD required_size;

char * comma;

char * p_in;

char * p_out;

char * subject_name;

std::string ret = std::string("certstore:") + cert_store_name + ":";

required_size = CertNameToStrA(cert->dwCertEncodingType,

&cert->pCertInfo->Subject,

/* Discard attribute names: */

CERT_SIMPLE_NAME_STR | CERT_NAME_STR_REVERSE_FLAG,

NULL,

0);

subject_name = static_cast<char *>(malloc(required_size+1));

if (!CertNameToStrA(cert->dwCertEncodingType,

&cert->pCertInfo->Subject,

/* Discard attribute names: */

CERT_SIMPLE_NAME_STR | CERT_NAME_STR_REVERSE_FLAG,

subject_name,

required_size)) {

return "";

if (!hstore) {

return "";

}

////Does this handle need to be freed as well?

hwnd = GetForegroundWindow();

if (!hwnd) {

hwnd = GetActiveWindow();

}

/* Call Windows dialog to select a suitable certificate */

cert = CryptUIDlgSelectCertificateFromStore(hstore,

hwnd,

cert_dlg_title,

cert_dlg_prompt,

exclude_columns,

0,

NULL);

if (hstore) {

CertCloseStore(hstore, 0);

}

if (cert) {

std::string ret = getCertUri(cert, cert_store_name);

CertFreeCertificateContext(cert);

return ret;

} else {

return "";

}

}

}

/*

* Copyright (c) 2012 Isode Limited, London, England.

* Licensed under the simplified BSD license.

* See Documentation/Licenses/BSD-simplified.txt for more information.

*/

#pragma once

#include <string>

namespace Swift {

std::string selectCAPICertificate();

}

#include <algorithm>

#include <cassert>

#include <QApplication>

#include <QBoxLayout>

#include <QComboBox>

#include <QDesktopWidget>

#include <QFileDialog>

#include <QStatusBar>

#include <QToolButton>

#include <QLabel>

#include <QMenuBar>

#include <QHBoxLayout>

#include <qdebug.h>

#include <QCloseEvent>

#include <QCursor>

#include <QMessageBox>

#include <QKeyEvent>

#include <Swift/Controllers/UIEvents/UIEventStream.h>

#include <Swift/Controllers/UIEvents/RequestXMLConsoleUIEvent.h>

#include <Swift/Controllers/UIEvents/RequestFileTransferListUIEvent.h>

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

#include <Swift/Controllers/SettingConstants.h>

#include <Swift/QtUI/QtUISettingConstants.h>

#include <Swiften/Base/Platform.h>

#include <Swiften/Base/Paths.h>

#include <QtAboutWidget.h>

#include <QtSwiftUtil.h>

#include <QtMainWindow.h>

#include <QtUtilities.h>

#ifdef HAVE_SCHANNEL

#include "CAPICertificateSelector.h"

#endif

namespace Swift{

QtLoginWindow::QtLoginWindow(UIEventStream* uiEventStream, SettingsProvider* settings) : QMainWindow(), settings_(settings) {

uiEventStream_ = uiEventStream;

setWindowTitle("Swift");

#ifndef Q_WS_MAC

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

#endif

QtUtilities::setX11Resource(this, "Main");

resize(200, 500);

setContentsMargins(0,0,0,0);

QWidget *centralWidget = new QWidget(this);

setCentralWidget(centralWidget);

QBoxLayout *topLayout = new QBoxLayout(QBoxLayout::TopToBottom, centralWidget);

stack_ = new QStackedWidget(centralWidget);

topLayout->addWidget(stack_);

topLayout->setMargin(0);

loginWidgetWrapper_ = new QWidget(this);

loginWidgetWrapper_->setSizePolicy(QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding));

QBoxLayout *layout = new QBoxLayout(QBoxLayout::TopToBottom, loginWidgetWrapper_);

layout->addStretch(2);

QLabel* logo = new QLabel(this);

logo->setPixmap(QPixmap(":/logo-shaded-text.256.png"));

logo->setScaledContents(true);

logo->setFixedSize(192,192);

QWidget *logoWidget = new QWidget(this);

QHBoxLayout *logoLayout = new QHBoxLayout();

logoLayout->setMargin(0);

logoLayout->addStretch(0);

logoLayout->addWidget(logo);

void QtLoginWindow::loggedOut() {

stack_->removeWidget(stack_->currentWidget());

stack_->addWidget(loginWidgetWrapper_);

stack_->setCurrentWidget(loginWidgetWrapper_);

setInitialMenus();

setIsLoggingIn(false);

}

void QtLoginWindow::setIsLoggingIn(bool loggingIn) {

/* Change the for loop as well if you add to this.*/

QWidget* widgets[5] = {username_, password_, remember_, loginAutomatically_, certificateButton_};

loginButton_->setText(loggingIn ? tr("Cancel") : tr("Connect"));

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

widgets[i]->setEnabled(!loggingIn);

}

bool eagle = settings_->getSetting(SettingConstants::FORGET_PASSWORDS);

remember_->setEnabled(!eagle);

loginAutomatically_->setEnabled(!eagle);

}

void QtLoginWindow::loginClicked() {

if (username_->isEnabled()) {

std::string banner = settings_->getSetting(QtUISettingConstants::CLICKTHROUGH_BANNER);

if (!banner.empty()) {

QMessageBox msgBox;

msgBox.setWindowTitle(tr("Confirm terms of use"));

msgBox.setText("");

msgBox.setInformativeText(P2QSTRING(banner));

msgBox.setStandardButtons(QMessageBox::Yes | QMessageBox::No);

msgBox.setDefaultButton(QMessageBox::No);

if (msgBox.exec() != QMessageBox::Yes) {

return;

}

}

if (settings_->getSetting(SettingConstants::FORGET_PASSWORDS)) { /* Mustn't remember logins */

username_->clearEditText();

password_->setText("");

}

} else {

onCancelLoginRequest();

}

}

void QtLoginWindow::setLoginAutomatically(bool loginAutomatically) {

loginAutomatically_->setChecked(loginAutomatically);

}

void QtLoginWindow::handleCertficateChecked(bool checked) {

if (checked) {

#ifdef HAVE_SCHANNEL

if (certificateFile_.isEmpty()) {

certificateButton_->setChecked(false);

}

#else

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

if (certificateFile_.isEmpty()) {

certificateButton_->setChecked(false);

}

#endif

}

else {

certificateFile_ = "";

}

}

void QtLoginWindow::handleAbout() {

if (!aboutDialog_) {

aboutDialog_ = new QtAboutWidget();

aboutDialog_->show();

}

else {

aboutDialog_->show();

aboutDialog_->raise();

aboutDialog_->activateWindow();

}

}

void QtLoginWindow::handleShowXMLConsole() {

uiEventStream_->send(boost::shared_ptr<RequestXMLConsoleUIEvent>(new RequestXMLConsoleUIEvent()));

}

void QtLoginWindow::handleShowFileTransferOverview() {

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

}

myenv.UseFlags(env["SWIFTOOLS_FLAGS"])

if myenv["HAVE_XSS"] :

myenv.UseFlags(env["XSS_FLAGS"])

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

myenv.Append(LIBS = ["X11"])

if myenv["HAVE_SPARKLE"] :

myenv.UseFlags(env["SPARKLE_FLAGS"])

myenv.UseFlags(env["SWIFTEN_FLAGS"])

myenv.UseFlags(env["SWIFTEN_DEP_FLAGS"])

if myenv.get("HAVE_GROWL", False) :

myenv.UseFlags(myenv["GROWL_FLAGS"])

myenv.Append(CPPDEFINES = ["HAVE_GROWL"])

if myenv["swift_mobile"] :

myenv.Append(CPPDEFINES = ["SWIFT_MOBILE"])

if myenv.get("HAVE_SNARL", False) :

myenv.UseFlags(myenv["SNARL_FLAGS"])

myenv.Append(CPPDEFINES = ["HAVE_SNARL"])

myenv.UseFlags(myenv["PLATFORM_FLAGS"])

myenv.Tool("qt4", toolpath = ["#/BuildTools/SCons/Tools"])

myenv.Tool("nsis", toolpath = ["#/BuildTools/SCons/Tools"])

myenv.Tool("wix", toolpath = ["#/BuildTools/SCons/Tools"])

qt4modules = ['QtCore', 'QtGui', 'QtWebKit']

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

qt4modules += ["QtDBus"]

myenv.EnableQt4Modules(qt4modules, debug = False)

myenv.Append(CPPPATH = ["."])

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

#myenv["LINKFLAGS"] = ["/SUBSYSTEM:CONSOLE"]

myenv.Append(LINKFLAGS = ["/SUBSYSTEM:WINDOWS"])

myenv.Append(LIBS = "qtmain")

if myenv.get("HAVE_SCHANNEL", 0) :

myenv.Append(LIBS = "Cryptui")

myenv.WriteVal("DefaultTheme.qrc", myenv.Value(generateDefaultTheme(myenv.Dir("#/Swift/resources/themes/Default"))))

sources = [

"main.cpp",

"QtAboutWidget.cpp",

"QtAvatarWidget.cpp",

"QtUIFactory.cpp",

"QtChatWindowFactory.cpp",

"QtChatWindow.cpp",

"QtClickableLabel.cpp",

"QtLoginWindow.cpp",

"QtMainWindow.cpp",

"QtProfileWindow.cpp",

"QtNameWidget.cpp",

"QtSettingsProvider.cpp",

"QtStatusWidget.cpp",

"QtScaledAvatarCache.cpp",

"QtSwift.cpp",

"QtURIHandler.cpp",

"QtChatView.cpp",

"QtChatTheme.cpp",

"QtChatTabs.cpp",

"QtSoundPlayer.cpp",

"QtSystemTray.cpp",

"QtCachedImageScaler.cpp",

"QtTabbable.cpp",

"QtTabWidget.cpp",

"QtTextEdit.cpp",

"QtXMLConsoleWidget.cpp",

"QtFileTransferListWidget.cpp",

"QtFileTransferListItemModel.cpp",

"QtAdHocCommandWindow.cpp",

"QtUtilities.cpp",

"QtBookmarkDetailWindow.cpp",