/*

* Copyright (c) 2010-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Swift/QtUI/QtChatTabs.h>

#include <algorithm>

#include <vector>

#include <QAction>

#include <QApplication>

#include <QCloseEvent>

#include <QCursor>

#include <QDesktopWidget>

#include <QLayout>

#include <QMenu>

#include <QTabBar>

#include <QTabWidget>

#include <QtGlobal>

#include <Swiften/Base/Log.h>

#include <Swift/Controllers/ChatMessageSummarizer.h>

#include <Swift/QtUI/QtSwiftUtil.h>

#include <Swift/QtUI/QtTabWidget.h>

#include <Swift/QtUI/QtTabbable.h>

#include <Swift/QtUI/Trellis/QtDynamicGridLayout.h>

#include <Swift/QtUI/Trellis/QtGridSelectionDialog.h>

namespace Swift {

QtChatTabs::QtChatTabs(bool singleWindow, SettingsProvider* settingsProvider, bool trellisMode) : QWidget(), singleWindow_(singleWindow), settingsProvider_(settingsProvider), trellisMode_(trellisMode), dynamicGrid_(nullptr), gridSelectionDialog_(nullptr) {

#ifndef Q_OS_MAC

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

#else

setAttribute(Qt::WA_ShowWithoutActivating);

#endif

dynamicGrid_ = new QtDynamicGridLayout(this, trellisMode);

connect(dynamicGrid_, SIGNAL(tabCloseRequested(int)), this, SLOT(handleTabCloseRequested(int)));

connect(dynamicGrid_, SIGNAL(onCurrentIndexChanged(int)), this, SLOT(handleCurrentTabIndexChanged(int)));

QVBoxLayout *layout = new QVBoxLayout;

layout->setSpacing(0);

layout->setContentsMargins(0, 0, 0, 0);

layout->addWidget(dynamicGrid_);

setLayout(layout);

if (trellisMode) {

// restore size

if (!gridSizeString.empty()) {

QByteArray gridSizeData = QByteArray::fromBase64(P2QSTRING(gridSizeString).toUtf8());

QDataStream dataStreamGridSize(&gridSizeData, QIODevice::ReadWrite);

QSize gridSize(1,1);

dataStreamGridSize >> gridSize;

dynamicGrid_->setDimensions(gridSize);

}

// restore positions

if (!tabPositionsString.empty()) {

QByteArray tabPositionsData = QByteArray::fromBase64(P2QSTRING(tabPositionsString).toUtf8());

QDataStream inTabPositions(&tabPositionsData, QIODevice::ReadWrite);

QHash<QString, QPoint> tabPositions;

inTabPositions >> tabPositions;

dynamicGrid_->setTabPositions(tabPositions);

}

}

gridSelectionDialog_ = new QtGridSelectionDialog();

// setup shortcuts

shortcuts_ << new QShortcut(QKeySequence(tr("CTRL+W", "Close chat tab.")), window(), SLOT(handleCloseTabShortcut()));

shortcuts_ << new QShortcut(QKeySequence(Qt::CTRL + Qt::Key_PageUp), window(), SLOT(handleRequestedPreviousTab()));

shortcuts_ << new QShortcut(QKeySequence(Qt::CTRL + Qt::Key_PageDown), window(), SLOT(handleRequestedNextTab()));

shortcuts_ << new QShortcut(QKeySequence(Qt::ALT + Qt::Key_A), window(), SLOT(handleRequestedActiveTab()));

}

QtChatTabs::~QtChatTabs() {

foreach (QShortcut* shortcut, shortcuts_) {

delete shortcut;

}

if (trellisMode_) {

storeTabPositions();

}

delete gridSelectionDialog_;

}

void QtChatTabs::closeEvent(QCloseEvent* event) {

unreads.push_back(std::pair<std::string, int>(Q2PSTRING(tab->windowTitle()), tab->getCount()));

}

}

std::string current(Q2PSTRING(qobject_cast<QtTabbable*>(dynamicGrid_->currentWidget())->windowTitle()));

ChatMessageSummarizer summary;

QString title = summary.getSummary(current, unreads).c_str();

setWindowTitle(title);

emit onTitleChanged(title);

}

void QtChatTabs::flash() {

#ifndef SWIFTEN_PLATFORM_MACOSX

QApplication::alert(this, 0);

#endif

}

void QtChatTabs::handleOpenLayoutChangeDialog() {

disconnect(gridSelectionDialog_, SIGNAL(currentGridSizeChanged(QSize)), dynamicGrid_, SLOT(setDimensions(QSize)));

gridSelectionDialog_->setCurrentGridSize(dynamicGrid_->getDimension());

gridSelectionDialog_->move(QCursor::pos());

connect(gridSelectionDialog_, SIGNAL(currentGridSizeChanged(QSize)), dynamicGrid_, SLOT(setDimensions(QSize)));

gridSelectionDialog_->show();

}

void QtChatTabs::storeTabPositions() {

// save size

QByteArray gridSizeData;

QDataStream dataStreamGridSize(&gridSizeData, QIODevice::ReadWrite);

dataStreamGridSize << dynamicGrid_->getDimension();

// save positions

QByteArray tabPositionsData;

QDataStream dataStreamTabPositions(&tabPositionsData, QIODevice::ReadWrite);

dynamicGrid_->updateTabPositions();

dataStreamTabPositions << dynamicGrid_->getTabPositions();

}

void QtChatTabs::resizeEvent(QResizeEvent*) {

emit geometryChanged();

}

void QtChatTabs::moveEvent(QMoveEvent*) {

emit geometryChanged();

}

void QtChatTabs::checkForFirstShow() {

if (!isVisible()) {

#ifndef Q_OS_MAC

showMinimized();

#else

/* https://bugreports.qt-project.org/browse/QTBUG-19194

* ^ When the above is fixed we can swap the below for just show();

* WA_ShowWithoutActivating seems to helpfully not work, so... */

QWidget* currentWindow = QApplication::activeWindow(); /* Remember who had focus if we're the current application*/

show();

QCoreApplication::processEvents(); /* Run through the eventloop to clear the show() */

if (currentWindow) {

currentWindow->activateWindow(); /* Set focus back */

}

#endif

}

}

}

/*

* Copyright (c) 2011 Vlad Voicu

* Licensed under the Simplified BSD license.

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

*/

/*

* Copyright (c) 2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Swift/QtUI/QtSpellCheckerWindow.h>

#include <QCoreApplication>

#include <QDir>

#include <QFileDialog>

#include <QStringList>

#include <QTimer>

#include <Swiften/Base/Log.h>

#include <Swift/QtUI/QtSwiftUtil.h>

#include <Swift/QtUI/QtUISettingConstants.h>

namespace Swift {

QtSpellCheckerWindow::QtSpellCheckerWindow(SettingsProvider* settings, QWidget* parent) : QDialog(parent) {

settings_ = settings;

ui_.setupUi(this);

#ifdef HAVE_HUNSPELL

ui_.hunspellOptions->show();

#else

ui_.hunspellOptions->hide();

QTimer::singleShot(0, this, SLOT(shrinkWindow()));

#endif

connect(ui_.spellChecker, SIGNAL(toggled(bool)), this, SLOT(handleChecker(bool)));

connect(ui_.cancel, SIGNAL(clicked()), this, SLOT(handleCancel()));

connect(ui_.apply, SIGNAL(clicked()), this, SLOT(handleApply()));

setFromSettings();

}

void QtSpellCheckerWindow::shrinkWindow() {

resize(0,0);

}

void QtSpellCheckerWindow::setFromSettings() {

}

void QtSpellCheckerWindow::setSupportedLanguages(const std::vector<std::string>& languages) {

languageItems_.clear();

ui_.languageView->clear();

for (const auto& shortLang : languages) {

auto locale = QLocale(P2QSTRING(shortLang));

auto label = QString("%1 ( %2 )").arg(locale.nativeLanguageName(), locale.nativeCountryName());

QListWidgetItem* item = new QListWidgetItem(label);

item->setData(Qt::UserRole, P2QSTRING(shortLang));

languageItems_[shortLang] = item;

ui_.languageView->addItem(item);

}

}

void QtSpellCheckerWindow::setActiveLanguage(const std::string& language) {

SWIFT_LOG_ASSERT(languageItems_.find(language) != languageItems_.end(), warning) << "Language '" << language << "' is not available." << std::endl;

if (languageItems_.find(language) != languageItems_.end()) {

languageItems_[language]->setSelected(true);

}

}

void QtSpellCheckerWindow::setAutomaticallyIdentifiesLanguage(bool isAutomaticallyIdentifying) {

ui_.languageView->setHidden(isAutomaticallyIdentifying);

}

void QtSpellCheckerWindow::handleChecker(bool state) {

setEnabled(state);

}

void QtSpellCheckerWindow::setEnabled(bool state) {

ui_.language->setEnabled(state);

}

void QtSpellCheckerWindow::handleApply() {

QList<QListWidgetItem* > selectedLanguage = ui_.languageView->selectedItems();

if (!selectedLanguage.empty()) {

}

this->done(0);

}

void QtSpellCheckerWindow::handleCancel() {

this->done(0);

}

}

#include <Swiften/Base/Paths.h>

#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>

#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

}

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_ = autoUpdaterFactory.createAutoUpdater(SWIFT_APPCAST_URL);

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_;

/*

* Copyright (c) 2010-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Swift/QtUI/QtTextEdit.h>

#include <boost/algorithm/string.hpp>

#include <boost/bind.hpp>

#include <boost/tuple/tuple.hpp>

#include <QApplication>

#include <QKeyEvent>

#include <QKeySequence>

#include <QMenu>

#include <QTextDocument>

#include <Swiften/Base/Log.h>

#include <SwifTools/SpellChecker.h>

#include <SwifTools/SpellCheckerFactory.h>

#include <Swift/QtUI/QtSpellCheckerWindow.h>

#include <Swift/QtUI/QtSwiftUtil.h>

#include <Swift/QtUI/QtUtilities.h>

namespace Swift {

QtTextEdit::QtTextEdit(SettingsProvider* settings, QWidget* parent) : QTextEdit(parent), checker_(nullptr), highlighter_(nullptr) {

connect(this, SIGNAL(textChanged()), this, SLOT(handleTextChanged()));

settings_ = settings;

#ifdef HAVE_SPELLCHECKER

setUpSpellChecker();

#endif

handleTextChanged();

QTextOption textOption = document()->defaultTextOption();

textOption.setWrapMode(QTextOption::WordWrap);

document()->setDefaultTextOption(textOption);

}

QtTextEdit::~QtTextEdit() {

delete checker_;

}

void QtTextEdit::keyPressEvent(QKeyEvent* event) {

int key = event->key();

Qt::KeyboardModifiers modifiers = event->modifiers();

if ((key == Qt::Key_Enter || key == Qt::Key_Return)

&& (modifiers == Qt::NoModifier || modifiers == Qt::KeypadModifier)) {

emit returnPressed();

}

else if (((key == Qt::Key_PageUp || key == Qt::Key_PageDown) && modifiers == Qt::ShiftModifier)

|| (key == Qt::Key_C && modifiers == Qt::ControlModifier && textCursor().selectedText().isEmpty())

|| (key == Qt::Key_W && modifiers == Qt::ControlModifier)

// suggestions are necessary

return;

}

cursor.setPosition(boost::get<0>(wordPosition), QTextCursor::MoveAnchor);

cursor.setPosition(boost::get<1>(wordPosition), QTextCursor::KeepAnchor);

std::vector<std::string> wordList;

checker_->getSuggestions(Q2PSTRING(cursor.selectedText()), wordList);

if (wordList.size() == 0) {

QAction* noSuggestions = new QAction(tr("No Suggestions"), menu);

noSuggestions->setDisabled(true);

menu->insertAction(insertPoint, noSuggestions);

}

else {

for (auto& word : wordList) {

QAction* wordAction = new QAction(word.c_str(), menu);

menu->insertAction(insertPoint, wordAction);

replaceWordActions_.push_back(wordAction);

}

}

menu->insertAction(insertPoint, menu->addSeparator());

}

}

#ifdef HAVE_SPELLCHECKER

void QtTextEdit::setUpSpellChecker() {

delete highlighter_;

highlighter_ = nullptr;

delete checker_;

checker_ = nullptr;

checker_ = SpellCheckerFactory().createSpellChecker();

if (checker_) {

if (!checker_->isAutomaticallyDetectingLanguage()) {

}

highlighter_ = new QtSpellCheckHighlighter(document(), checker_);

}

else {

// Spellchecking is not working, as we did not get a valid checker from the factory. Disable spellchecking.

SWIFT_LOG(warning) << "Spellchecking is currently misconfigured in Swift (e.g. missing dictionary or broken dictionary file). Disable spellchecking." << std::endl;

}

}

}

#endif

void QtTextEdit::spellCheckerSettingsWindow() {

if (!spellCheckerWindow_) {

spellCheckerWindow_ = new QtSpellCheckerWindow(settings_);

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

spellCheckerWindow_->show();

}

else {

spellCheckerWindow_->show();

spellCheckerWindow_->raise();

spellCheckerWindow_->activateWindow();

}

if (checker_) {

spellCheckerWindow_->setAutomaticallyIdentifiesLanguage(checker_->isAutomaticallyDetectingLanguage());

if (!checker_->isAutomaticallyDetectingLanguage()) {

spellCheckerWindow_->setSupportedLanguages(checker_->supportedLanguages());

spellCheckerWindow_->setActiveLanguage(checker_->activeLanguage());

}

}

}

void QtTextEdit::handleSettingChanged(const std::string& settings) {

#ifdef HAVE_SPELLCHECKER

setUpSpellChecker();

if (highlighter_) {

highlighter_->rehighlight();

}

#endif

}

}

}

/*

* 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);

}

/*

* 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;

};

}