Swift

BuildVersion.h

*.dmg

/*

* Licensed under the GNU General Public License v3.

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

*/

#include "Swift/QtUI/Roster/GroupItemDelegate.h"

#include "Swift/QtUI/ChatList/ChatListItem.h"

#include "Swift/QtUI/ChatList/ChatListMUCItem.h"

#include "Swift/QtUI/ChatList/ChatListGroupItem.h"

namespace Swift {

ChatListItem* item = static_cast<ChatListItem*>(index.internalPointer());

if (item && dynamic_cast<ChatListMUCItem*>(item)) {

return mucSizeHint(option, index);

return groupDelegate_->sizeHint(option, index);

}

return QStyledItemDelegate::sizeHint(option, index);

return QSize(150, sizeByText);

}

void ChatListDelegate::paint(QPainter* painter, const QStyleOptionViewItem& option, const QModelIndex& index) const {

ChatListItem* item = static_cast<ChatListItem*>(index.internalPointer());

if (item && dynamic_cast<ChatListMUCItem*>(item)) {

paintMUC(painter, option, dynamic_cast<ChatListMUCItem*>(item));

ChatListGroupItem* group = dynamic_cast<ChatListGroupItem*>(item);

groupDelegate_->paint(painter, option, group->data(Qt::DisplayRole).toString(), group->rowCount(), option.state & QStyle::State_Open);

QStyledItemDelegate::paint(painter, option, index);

}

}

painter->setPen(QPen(QColor(160,160,160)));

QRect detailRegion(textRegion.adjusted(0, nameHeight, 0, 0));

painter->restore();

}

}

/*

* Licensed under the GNU General Public License v3.

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

*/

namespace Swift {

class ChatListMUCItem;

class ChatListDelegate : public QStyledItemDelegate {

public:

ChatListDelegate();

void paint(QPainter* painter, const QStyleOptionViewItem& option, const QModelIndex& index) const;

private:

void paintMUC(QPainter* painter, const QStyleOptionViewItem& option, ChatListMUCItem* item) const;

QSize mucSizeHint(const QStyleOptionViewItem& /*option*/, const QModelIndex& /*index*/ ) const;

DelegateCommons common_;

GroupItemDelegate* groupDelegate_;

/*

* Licensed under the GNU General Public License v3.

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

*/

namespace Swift {

class ChatListGroupItem : public ChatListItem {

public:

void remove(int index) {items_.removeAt(index);};

int rowCount() {return items_.size();};

ChatListItem* item(int i) {return items_[i];};

QString name_;

QList<ChatListItem*> items_;

};

}

}

return bookmark_;

}

#include "Swift/QtUI/ChatList/ChatListItem.h"

namespace Swift {

class ChatListMUCItem : public ChatListItem {

public:

ChatListMUCItem(const MUCBookmark& bookmark, ChatListGroupItem* parent);

QVariant data(int role) const;

private:

MUCBookmark bookmark_;

/*

* Licensed under the GNU General Public License v3.

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

*/

namespace Swift {

ChatListModel::ChatListModel() {

mucBookmarks_ = new ChatListGroupItem(tr("Bookmarked Rooms"), root_);

root_->addItem(mucBookmarks_);

}

emit layoutAboutToBeChanged();

mucBookmarks_->clear();

emit layoutChanged();

}

}

int ChatListModel::columnCount(const QModelIndex& /*parent*/) const {

return 1;

}

/*

* Licensed under the GNU General Public License v3.

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

*/

#include <QAbstractItemModel>

#include <QList>

namespace Swift {

class ChatListModel : public QAbstractItemModel {

QModelIndex parent(const QModelIndex& index) const;

int rowCount(const QModelIndex& parent = QModelIndex()) const;

ChatListItem* getItemForIndex(const QModelIndex& index) const;

private:

ChatListGroupItem* mucBookmarks_;

ChatListGroupItem* root_;

};

/*

* Licensed under the GNU General Public License v3.

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

*/

#include <QContextMenuEvent>

#include "Swift/QtUI/ChatList/ChatListMUCItem.h"

#include "Swift/QtUI/QtAddBookmarkWindow.h"

#include "Swift/QtUI/QtEditBookmarkWindow.h"

#include "Swift/Controllers/UIEvents/JoinMUCUIEvent.h"

#include "Swift/Controllers/UIEvents/AddMUCBookmarkUIEvent.h"

#include "Swift/Controllers/UIEvents/RemoveMUCBookmarkUIEvent.h"

#include "Swift/Controllers/UIEvents/EditMUCBookmarkUIEvent.h"

}

void QtChatListWindow::handleItemActivated(const QModelIndex& index) {

ChatListItem* item = model_->getItemForIndex(index);

}

}

}

void QtChatListWindow::addMUCBookmark(const MUCBookmark& bookmark) {

model_->removeMUCBookmark(bookmark);

}

void QtChatListWindow::handleRemoveBookmark() {

ChatListMUCItem* mucItem = dynamic_cast<ChatListMUCItem*>(contextMenuItem_);

if (!mucItem) return;

void QtChatListWindow::contextMenuEvent(QContextMenuEvent* event) {

QModelIndex index = indexAt(event->pos());

ChatListItem* baseItem = index.isValid() ? static_cast<ChatListItem*>(index.internalPointer()) : NULL;

contextMenuItem_ = baseItem;

}

ChatListMUCItem* mucItem = dynamic_cast<ChatListMUCItem*>(baseItem);

if (mucItem) {

mucMenu_->exec(QCursor::pos());

}

}

}

/*

* Licensed under the GNU General Public License v3.

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

*/

void addMUCBookmark(const MUCBookmark& bookmark);

void removeMUCBookmark(const MUCBookmark& bookmark);

void setBookmarksEnabled(bool enabled);

private slots:

void handleItemActivated(const QModelIndex&);

void handleAddBookmark();

public:

ChatSnippet(bool appendToPrevious);

virtual ~ChatSnippet();

virtual const QString& getContent() const = 0;

virtual QString getContinuationElementID() const { return ""; }

bool getAppendToPrevious() const {

return appendToPrevious_;

}

static QString escape(const QString& original) {

QString result(original);

result.replace("%message%", "&#37;message&#37;");

return result;

}

protected:

void setContinuationFallbackSnippet(boost::shared_ptr<ChatSnippet> continuationFallback) {

continuationFallback_ = continuationFallback;

}

private:

bool appendToPrevious_;

boost::shared_ptr<ChatSnippet> continuationFallback_;

#pragma once

#include <QTreeView>

MUCSearchRoomItem(const QString& node, MUCSearchServiceItem* parent);

MUCSearchServiceItem* getParent();

QVariant data(int role);

private:

MUCSearchServiceItem* parent_;

QString node_;

default: return QVariant();

}

}

private:

QList<MUCSearchItem*> rooms_;

QString jidString_;

this->type = type;

QImage image;

}

if (image.isNull()) {

QString fileName = QFileDialog::getOpenFileName(this, tr("Select picture"), "", tr("Image Files (*.png *.jpg *.gif)"));

if (!fileName.isEmpty()) {

ByteArray data;

QBuffer buffer;

buffer.open(QIODevice::ReadOnly);

QString type = QImageReader::imageFormat(&buffer).toLower();

if (!type.isEmpty()) {

<item row="4" column="1">

<widget class="QCheckBox" name="autojoin_">

<property name="text">

</property>

<property name="checked">

<bool>true</bool>

#include "QtChatTabs.h"

#include <algorithm>

#include <QCloseEvent>

#include <QDesktopWidget>

default : tabTextColor = QColor();

}

tabs_->tabBar()->setTabTextColor(index, tabTextColor);

for (int i = 0; i < tabs_->count(); i++) {

QtTabbable* tab = qobject_cast<QtTabbable*>(tabs_->widget(i));

if (tab) {

}

}

}

void QtChatTabs::flash() {

}

return qrc_ ? "qrc" + themePath_ : "file://" + themePath_;

}

class QtChatTheme {

public:

QtChatTheme(const QString& themePath);

private:

enum files {Header = 0, Footer, Content, Status, Topic, FileTransferRequest, IncomingContent, IncomingNextContent, IncomingContext, IncomingNextContext, OutgoingContent, OutgoingNextContent, OutgoingContext, OutgoingNextContext, Template, MainCSS, TemplateDefault, EndMarker};

#include <QMessageBox>

#include <QApplication>

#include "QtWebView.h"

#include "QtChatTheme.h"

namespace Swift {

theme_ = theme;

QVBoxLayout* mainLayout = new QVBoxLayout(this);

connect(webView_, SIGNAL(loadFinished(bool)), SLOT(handleViewLoadFinished(bool)));

connect(webView_, SIGNAL(gotFocus()), SIGNAL(gotFocus()));

connect(webView_, SIGNAL(clearRequested()), SLOT(handleClearRequested()));

#ifdef Q_WS_X11

/* To give a border on Linux, where it looks bad without */

QStackedWidget* stack = new QStackedWidget(this);

mainLayout->addWidget(webView_);

#endif

webPage_ = new QWebPage(this);

webPage_->setLinkDelegationPolicy(QWebPage::DelegateAllLinks);

webView_->setPage(webPage_);

connect(webPage_, SIGNAL(selectionChanged()), SLOT(copySelectionToClipboard()));

if (viewReady_) {

addToDOM(snippet);

} else {

}

}

QWebElement QtChatView::snippetToDOM(boost::shared_ptr<ChatSnippet> snippet) {

QWebElement newElement = newInsertPoint_.clone();

Q_ASSERT(!newElement.isNull());

return newElement;

}

newInsertPoint_.prependOutside(newElement);

}

lastElement_ = newElement;

}

void QtChatView::replaceLastMessage(const QString& newMessage) {

assert(viewReady_);

rememberScrolledToBottom();

assert(!lastElement_.isNull());

QWebElement replace = lastElement_.findFirst("span.swift_message");

replace.setInnerXml(ChatSnippet::escape(note));

}

void QtChatView::copySelectionToClipboard() {

if (!webPage_->selectedText().isEmpty()) {

webPage_->triggerAction(QWebPage::Copy);

QDesktopServices::openUrl(url);

}

void QtChatView::handleViewLoadFinished(bool ok) {

Q_ASSERT(ok);

viewReady_ = true;

}

void QtChatView::resetView() {

connect(webPage_->mainFrame(), SIGNAL(contentsSizeChanged(const QSize&)), this, SLOT(handleFrameSizeChanged()), Qt::UniqueConnection);

}

}

#include "ChatSnippet.h"

class QWebPage;

class QUrl;

Q_OBJECT

public:

QtChatView(QtChatTheme* theme, QWidget* parent);

void addMessage(boost::shared_ptr<ChatSnippet> snippet);

void replaceLastMessage(const QString& newMessage);

void replaceLastMessage(const QString& newMessage, const QString& note);

void rememberScrolledToBottom();

void setAckXML(const QString& id, const QString& xml);

signals:

void gotFocus();

public slots:

void copySelectionToClipboard();

void handleLinkClicked(const QUrl&);

void handleKeyPressEvent(QKeyEvent* event);

void resetView();

private slots:

void handleViewLoadFinished(bool);

private:

void headerEncode();

void messageEncode();

void addToDOM(boost::shared_ptr<ChatSnippet> snippet);

QWebElement snippetToDOM(boost::shared_ptr<ChatSnippet> snippet);

bool isAtBottom_;

QtWebView* webView_;

QWebPage* webPage_;

QtChatTheme* theme_;

QWebElement newInsertPoint_;

QWebElement lastElement_;

QWebElement document_;

};

/*

* Licensed under the GNU General Public License v3.

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

*/

#include "QtChatWindow.h"

#include "QtSwiftUtil.h"

#include "Swift/Controllers/Roster/Roster.h"

#include "SwifTools/Linkify.h"

#include "QtChatView.h"

#include "MessageSnippet.h"

#include "SystemMessageSnippet.h"

#include "QtTextEdit.h"

#include "QtScaledAvatarCache.h"

#include "SwifTools/TabComplete.h"

#include <QApplication>

#include <QBoxLayout>

#include <QCloseEvent>

#include <QTextEdit>

#include <QTime>

#include <QUrl>

namespace Swift {

unreadCount_ = 0;

inputEnabled_ = true;

completer_ = NULL;

theme_ = theme;

updateTitleWithUnreadCount();

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

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

layout->setSpacing(2);

messageLog_ = new QtChatView(theme, this);

treeWidget_->hide();

QWidget* midBar = new QWidget(this);

layout->addWidget(midBar);

labelsWidget_->setSizeAdjustPolicy(QComboBox::AdjustToContents);

midBarLayout->addWidget(labelsWidget_,0);

input_ = new QtTextEdit(this);

input_->setAcceptRichText(false);

inputClearing_ = false;

contactIsTyping_ = false;

connect(input_, SIGNAL(returnPressed()), this, SLOT(returnPressed()));

connect(input_, SIGNAL(textChanged()), this, SLOT(handleInputChanged()));

setFocusProxy(input_);

midBar->setFocusProxy(input_);

messageLog_->setFocusProxy(input_);

connect(qApp, SIGNAL(focusChanged(QWidget*, QWidget*)), this, SLOT(qAppFocusChanged(QWidget*, QWidget*)));

connect(messageLog_, SIGNAL(gotFocus()), input_, SLOT(setFocus()));

resize(400,300);

}

QtChatWindow::~QtChatWindow() {

}

void QtChatWindow::setTabComplete(TabComplete* completer) {

emit requestActiveTab();

} else if (key == Qt::Key_Tab) {

tabComplete();

} else {

messageLog_->handleKeyPressEvent(event);

}

}

void QtChatWindow::tabComplete() {

if (!completer_) {

return;

}

void QtChatWindow::setRosterModel(Roster* roster) {

}

void QtChatWindow::setAvailableSecurityLabels(const std::vector<SecurityLabelsCatalog::Item>& labels) {

}

}

SecurityLabelsCatalog::Item QtChatWindow::getSelectedSecurityLabel() {

assert(labelsWidget_->isEnabled());

return availableLabels_[labelsWidget_->currentIndex()];

}

void QtChatWindow::convertToMUC() {

treeWidget_->show();

}

if (isWidgetSelected()) {

input_->setFocus();

onAllMessagesRead();

}

}

void QtChatWindow::setInputEnabled(bool enabled) {

inputEnabled_ = enabled;

}

void QtChatWindow::showEvent(QShowEvent* event) {

QtTabbable::AlertType QtChatWindow::getWidgetAlertState() {

if (contactIsTyping_) {

return ImpendingActivity;

if (unreadCount_ > 0) {

return WaitingActivity;

}

if (isWidgetSelected()) {

onAllMessagesRead();

}

QString scaledAvatarPath = QtScaledAvatarCache(32).getScaledAvatarPath(avatarPath.c_str());

QString htmlString;

QString styleSpanEnd = style == "" ? "" : "</span>";

htmlString += styleSpanStart + messageHTML + styleSpanEnd;

QString qAvatarPath = scaledAvatarPath.isEmpty() ? "qrc:/icons/avatar.png" : QUrl::fromLocalFile(scaledAvatarPath).toEncoded();

std::string id = id_.generateID();

messageLog_->addMessage(boost::shared_ptr<ChatSnippet>(new MessageSnippet(htmlString, Qt::escape(P2QSTRING(senderName)), B2QDATE(time), qAvatarPath, senderIsSelf, appendToPrevious, theme_, P2QSTRING(id))));

previousSenderName_ = P2QSTRING(senderName);

previousMessageWasSystem_ = false;

previousMessageWasPresence_ = false;

return id;

}

return addMessage(" *" + message + "*", senderName, senderIsSelf, label, avatarPath, "font-style:italic ", time);

}

void QtChatWindow::addErrorMessage(const std::string& errorMessage) {

if (isWidgetSelected()) {

onAllMessagesRead();

QString errorMessageHTML(Qt::escape(P2QSTRING(errorMessage)));

errorMessageHTML.replace("\n","<br/>");

previousMessageWasSelf_ = false;

previousMessageWasSystem_ = true;

previousMessageWasPresence_ = false;

}

void QtChatWindow::addSystemMessage(const std::string& message) {

previousMessageWasSelf_ = false;

previousMessageWasSystem_ = true;

previousMessageWasPresence_ = false;

}

void QtChatWindow::addPresenceMessage(const std::string& message) {

return;

}

messageLog_->scrollToBottom();

inputClearing_ = true;

input_->clear();

inputClearing_ = false;

}

}

void QtChatWindow::show() {

emit windowOpening();

}

}

void QtChatWindow::moveEvent(QMoveEvent*) {

}

void QtChatWindow::replaceLastMessage(const std::string& message) {

messageLog_->replaceLastMessage(P2QSTRING(Linkify::linkify(message)));

}

}

/*

* Licensed under the GNU General Public License v3.

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

*/

class QTextEdit;

class QLineEdit;

class QComboBox;

namespace Swift {

class QtChatView;

class QtChatTheme;

class TreeWidget;

class QtTextEdit;

class UIEventStream;

class QtChatWindow : public QtTabbable, public ChatWindow {

Q_OBJECT

public:

void addSystemMessage(const std::string& message);

void addPresenceMessage(const std::string& message);

void addErrorMessage(const std::string& errorMessage);

void show();

void activate();

void setUnreadMessageCount(int count);

void replaceLastMessage(const std::string& message);

void setAckState(const std::string& id, AckState state);

void flash();

signals:

void geometryChanged();

protected slots:

void qAppFocusChanged(QWidget* old, QWidget* now);

void resizeEvent(QResizeEvent* event);

void moveEvent(QMoveEvent* event);

protected:

void showEvent(QShowEvent* event);

void returnPressed();

void handleInputChanged();

void handleKeyPressEvent(QKeyEvent* event);

private:

void updateTitleWithUnreadCount();

void tabComplete();

std::string addMessage(const std::string &message, const std::string &senderName, bool senderIsSelf, boost::shared_ptr<SecurityLabel> label, const std::string& avatarPath, const QString& style, const boost::posix_time::ptime& time);

int unreadCount_;

bool contactIsTyping_;

QString contact_;

QtChatView* messageLog_;

QtChatTheme* theme_;

QtTextEdit* input_;

QComboBox* labelsWidget_;

TabComplete* completer_;

std::vector<SecurityLabelsCatalog::Item> availableLabels_;

bool previousMessageWasSelf_;

bool previousMessageWasSystem_;

bool previousMessageWasPresence_;

QString previousSenderName_;

bool inputClearing_;

UIEventStream* eventStream_;

bool inputEnabled_;

IDGenerator id_;

};

}

namespace Swift {

QtChatWindowFactory::QtChatWindowFactory(QSplitter* splitter, QtSettingsProvider* settings, QtChatTabs* tabs, const QString& themePath) : themePath_(themePath) {

settings_ = settings;

tabs_ = tabs;

if (splitter) {

splitter->addWidget(tabs_);

} else if (tabs_) {

if (chatTabsGeometryVariant.isValid()) {

tabs_->restoreGeometry(chatTabsGeometryVariant.toByteArray());

}

theme_ = new QtChatTheme(""); /* Use the inbuilt theme */

}

}

QtChatWindow *chatWindow = new QtChatWindow(P2QSTRING(contact.toString()), theme_, eventStream);

if (tabs_) {

tabs_->addTab(chatWindow);

} else {

if (chatGeometryVariant.isValid()) {

chatWindow->restoreGeometry(chatGeometryVariant.toByteArray());

}

}

void QtChatWindowFactory::handleWindowGeometryChanged() {

}

}

QtChatWindowFactory(QSplitter* splitter, QtSettingsProvider* settings, QtChatTabs* tabs, const QString& themePath);

~QtChatWindowFactory();

ChatWindow* createChatWindow(const JID &contact, UIEventStream* eventStream);

private slots:

void handleWindowGeometryChanged();

private:

QString themePath_;

QtSettingsProvider* settings_;

connect(removeButton, SIGNAL(clicked()), this, SLOT(handleRemoveContact()));

buttonLayout->addWidget(removeButton);

QPushButton* okButton = new QPushButton(tr("OK"), this);

connect(okButton, SIGNAL(clicked()), this, SLOT(handleUpdateContact()));

buttonLayout->addStretch();

buttonLayout->addWidget(okButton);

#include "QtJoinMUCWindow.h"

#include "QtSwiftUtil.h"

namespace Swift {

ui.setupUi(this);

#if QT_VERSION >= 0x040700

ui.room->setPlaceholderText(tr("someroom@rooms.example.com"));

lastSetNick = Q2PSTRING(ui.nickName->text());

JID room(Q2PSTRING(ui.room->text()));

hide();

}

#include <Swift/QtUI/ui_QtJoinMUCWindow.h>

namespace Swift {

class QtJoinMUCWindow : public QWidget, public JoinMUCWindow {

Q_OBJECT

public:

virtual void setNick(const std::string& nick);

virtual void setMUC(const std::string& nick);

private:

Ui::QtJoinMUCWindow ui;

std::string lastSetNick;

};

}

/*

* Licensed under the GNU General Public License v3.

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

*/

#include "QtLoginWindow.h"

#include <boost/bind.hpp>

#include <algorithm>

#include <cassert>

#include "Swift/Controllers/UIEvents/UIEventStream.h"

#include "Swift/Controllers/UIEvents/RequestXMLConsoleUIEvent.h"

#include "Swift/Controllers/UIEvents/ToggleSoundsUIEvent.h"

#include "Swift/Controllers/UIEvents/ToggleNotificationsUIEvent.h"

#include "Swiften/Base/Platform.h"

namespace Swift{

uiEventStream_ = uiEventStream;

setWindowTitle("Swift");

stack_ = new QStackedWidget(centralWidget);

topLayout->addWidget(stack_);

topLayout->setMargin(0);

layout->addStretch(2);

QLabel* logo = new QLabel(this);

layout->addWidget(loginAutomatically_);

connect(loginButton_, SIGNAL(clicked()), SLOT(loginClicked()));

#ifdef SWIFTEN_PLATFORM_MACOSX

menuBar_ = new QMenuBar(NULL);

#else

connect(aboutAction, SIGNAL(triggered()), SLOT(handleAbout()));

swiftMenu_->addAction(aboutAction);

toggleSoundsAction_ = new QAction(tr("&Play Sounds"), this);

toggleSoundsAction_->setCheckable(true);

this->show();

}

bool QtLoginWindow::eventFilter(QObject *obj, QEvent *event) {

if (obj == username_->view() && event->type() == QEvent::KeyPress) {

QKeyEvent *keyEvent = static_cast<QKeyEvent*>(event);

}

void QtLoginWindow::loggedOut() {

setInitialMenus();

setIsLoggingIn(false);

}

void QtLoginWindow::loginClicked() {

if (username_->isEnabled()) {

onLoginRequest(Q2PSTRING(username_->currentText()), Q2PSTRING(password_->text()), Q2PSTRING(certificateFile_), remember_->isChecked(), loginAutomatically_->isChecked());

} else {

onCancelLoginRequest();

}

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

}

void QtLoginWindow::handleToggleSounds(bool enabled) {

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

}

void QtLoginWindow::morphInto(MainWindow *mainWindow) {

QtMainWindow *qtMainWindow = dynamic_cast<QtMainWindow*>(mainWindow);

assert(qtMainWindow);

stack_->addWidget(qtMainWindow);

stack_->setCurrentWidget(qtMainWindow);

setEnabled(true);

/*

* Licensed under the GNU General Public License v3.

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

*/

#include <QMainWindow>

#include <QPointer>

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

virtual void setLoginAutomatically(bool loginAutomatically);

virtual void setIsLoggingIn(bool loggingIn);

void selectUser(const std::string& user);

bool askUserToTrustCertificatePermanently(const std::string& message, Certificate::ref certificate);

void hide();

void handleCertficateChecked(bool);

void handleQuit();

void handleShowXMLConsole();

void handleToggleSounds(bool enabled);

void handleToggleNotifications(bool enabled);

void handleAbout();

private:

void setInitialMenus();

QStringList usernames_;

QStringList passwords_;

QStringList certificateFiles_;

QAction* toggleNotificationsAction_;

UIEventStream* uiEventStream_;

QPointer<QtAboutWidget> aboutDialog_;

};

}

/*

* Licensed under the GNU General Public License v3.

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

*/

#include <QAction>

#include <QTabWidget>

namespace Swift {

QtMainWindow::QtMainWindow(QtSettingsProvider* settings, UIEventStream* uiEventStream) : QWidget(), MainWindow(false) {

uiEventStream_ = uiEventStream;

setSizePolicy(QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding));

QBoxLayout *mainLayout = new QBoxLayout(QBoxLayout::TopToBottom, this);

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

contactTabLayout->setSpacing(0);

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

contactTabLayout->addWidget(treeWidget_);

tabs_->addTab(contactsTabWidget_, tr("&Contacts"));

connect(eventWindow_, SIGNAL(onNewEventCountUpdated(int)), this, SLOT(handleEventCountUpdated(int)));

chatListWindow_ = new QtChatListWindow(uiEventStream_);

tabs_->addTab(chatListWindow_, tr("C&hats"));

this->setLayout(mainLayout);

chatUserAction_ = new QAction(tr("Start &Chat"), this);

connect(chatUserAction_, SIGNAL(triggered(bool)), this, SLOT(handleChatUserActionTriggered(bool)));

actionsMenu->addAction(chatUserAction_);

actionsMenu->addSeparator();

QAction* signOutAction = new QAction(tr("&Sign Out"), this);

connect(signOutAction, SIGNAL(triggered()), SLOT(handleSignOutAction()));

actionsMenu->addAction(signOutAction);

lastOfflineState_ = false;

uiEventStream_->onUIEvent.connect(boost::bind(&QtMainWindow::handleUIEvent, this, _1));

uiEventStream_->onUIEvent.disconnect(boost::bind(&QtMainWindow::handleUIEvent, this, _1));

}

QtEventWindow* QtMainWindow::getEventWindow() {

return eventWindow_;

}

void QtMainWindow::handleEventCountUpdated(int count) {

QColor eventTabColor = (count == 0) ? QColor() : QColor(255, 0, 0); // invalid resets to default

tabs_->tabBar()->setTabTextColor(eventIndex, eventTabColor);

QString text = tr("&Notices");

if (count > 0) {

tabs_->setTabText(eventIndex, text);

}

void QtMainWindow::handleAddUserActionTriggered(bool /*checked*/) {

boost::shared_ptr<UIEvent> event(new RequestAddUserDialogUIEvent());

uiEventStream_->send(event);

meView_->setConnecting();

}

}

/*

* Licensed under the GNU General Public License v3.

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

*/

#include <QWidget>

#include <QMenu>

#include "Swift/Controllers/UIInterfaces/MainWindow.h"

#include "Swift/QtUI/QtRosterHeader.h"

#include "Swift/QtUI/EventViewer/QtEventWindow.h"

class QPushButton;

class QToolBar;

class QAction;

class QTabWidget;

namespace Swift {

class TreeWidget;

class UIEventStream;

class QtTabWidget;

Q_OBJECT

public:

QtMainWindow(QtSettingsProvider*, UIEventStream* eventStream);

std::vector<QMenu*> getMenus() {return menus_;}

void setMyNick(const std::string& name);

void setMyJID(const JID& jid);

QtEventWindow* getEventWindow();

QtChatListWindow* getChatListWindow();

void setRosterModel(Roster* roster);

private slots:

void handleStatusChanged(StatusShow::Type showType, const QString &statusMessage);

void handleUIEvent(boost::shared_ptr<UIEvent> event);

void handleEditProfileAction();

void handleAddUserActionTriggered(bool checked);

void handleChatUserActionTriggered(bool checked);

void handleEventCountUpdated(int count);

void handleEditProfileRequest();

private:

std::vector<QMenu*> menus_;

QtRosterHeader* meView_;

QAction* addUserAction_;

QAction* editUserAction_;

QAction* chatUserAction_;

QAction* showOfflineAction_;

QtTabWidget* tabs_;

QWidget* contactsTabWidget_;

QWidget* eventsTabWidget_;

QtChatListWindow* chatListWindow_;

UIEventStream* uiEventStream_;

bool lastOfflineState_;

};

}

layout->addWidget(okButton);

} else {

QPushButton* yesButton = new QPushButton(tr("Yes"), this);

connect(yesButton, SIGNAL(clicked()), this, SLOT(handleYes()));

QPushButton* noButton = new QPushButton(tr("No"), this);

connect(noButton, SIGNAL(clicked()), this, SLOT(handleNo()));

QPushButton* deferButton = new QPushButton(tr("Defer"), this);

connect(deferButton, SIGNAL(clicked()), this, SLOT(handleDefer()));

QHBoxLayout* buttonLayout = new QHBoxLayout();

/*

* Licensed under the GNU General Public License v3.

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

*/

#include "QtUIFactory.h"

#include "QtChatWindowFactory.h"

#include <Swiften/Base/Log.h>

#include "SwifTools/Application/PlatformApplicationPathProvider.h"

#include <string>

#include "Swiften/Base/Platform.h"

#include "Swiften/Elements/Presence.h"

#include "Swiften/Client/Client.h"

#include "Swift/Controllers/MainController.h"

#include "Swift/Controllers/BuildVersion.h"

#include "SwifTools/AutoUpdater/AutoUpdater.h"

#include "SwifTools/AutoUpdater/PlatformAutoUpdaterFactory.h"

#if defined(SWIFTEN_PLATFORM_WINDOWS)

#include "WindowsNotifier.h"

#include "SwifTools/Notifier/GrowlNotifier.h"

#elif defined(SWIFTEN_PLATFORM_LINUX)

#include "FreeDesktopNotifier.h"

#else

#include "SwifTools/Notifier/NullNotifier.h"

#endif

#if defined(SWIFTEN_PLATFORM_MACOSX)

#include "SwifTools/Dock/MacOSXDock.h"

#include "SwifTools/Dock/NullDock.h"

namespace Swift{

("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")

;

return result;

}

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

splitter_ = new QSplitter();

} else {

tabs_ = options.count("no-tabs") && !(splitter_ > 0) ? NULL : new QtChatTabs();

bool startMinimized = options.count("start-minimized") > 0;

settings_ = new QtSettingsProvider();

applicationPathProvider_ = new PlatformApplicationPathProvider(SWIFT_APPLICATION_NAME);

storagesFactory_ = new FileStoragesFactory(applicationPathProvider_->getDataDir());

dock_ = new NullDock();

#endif

if (splitter_) {

splitter_->show();

}

certificateStorageFactory_,

dock_,

notifier_,

mainControllers_.push_back(mainController);

}

}

delete tabs_;

delete splitter_;

delete dock_;

delete soundPlayer_;

delete chatWindowFactory_;

#if defined(SWIFTEN_PLATFORM_WINDOWS)

#include "WindowsNotifier.h"

#endif

namespace po = boost::program_options;

class QtMUCSearchWindowFactory;

class QtUserSearchWindowFactory;

class EventLoop;

class QtSwift : public QObject {

Q_OBJECT

QSplitter* splitter_;

QtSoundPlayer* soundPlayer_;

Dock* dock_;

QtChatTabs* tabs_;

ApplicationPathProvider* applicationPathProvider_;

StoragesFactory* storagesFactory_;

CertificateStorageFactory* certificateStorageFactory_;

AutoUpdater* autoUpdater_;

Notifier* notifier_;

#if defined(SWIFTEN_PLATFORM_MACOSX)

CocoaApplication cocoaApplication_;

#endif

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

*/

#include <QFontMetrics>

#include <QKeyEvent>

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

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

emit returnPressed();

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

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

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

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

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

|| (key == Qt::Key_A && modifiers == Qt::AltModifier)

|| (key == Qt::Key_Tab)

) {

emit unhandledKeyPressEvent(event);

QTextEdit::keyPressEvent(event);

}

}

#include "UserSearch/QtUserSearchWindow.h"

#include "QtProfileWindow.h"

#include "QtContactEditWindow.h"

namespace Swift {

QtUIFactory::QtUIFactory(QtSettingsProvider* settings, QtChatTabs* tabs, QSplitter* netbookSplitter, QtSystemTray* systemTray, QtChatWindowFactory* chatWindowFactory, bool startMinimized) : settings(settings), tabs(tabs), netbookSplitter(netbookSplitter), systemTray(systemTray), chatWindowFactory(chatWindowFactory), lastMainWindow(NULL), loginWindow(NULL), startMinimized(startMinimized) {

}

XMLConsoleWidget* QtUIFactory::createXMLConsoleWidget() {

return widget;

}

MainWindow* QtUIFactory::createMainWindow(UIEventStream* eventStream) {

lastMainWindow = new QtMainWindow(settings, eventStream);

}

ChatWindow* QtUIFactory::createChatWindow(const JID& contact, UIEventStream* eventStream) {

}

UserSearchWindow* QtUIFactory::createUserSearchWindow(UserSearchWindow::Type type, UIEventStream* eventStream, const std::set<std::string>& groups) {

return new QtUserSearchWindow(eventStream, type, groups);

};

}

ProfileWindow* QtUIFactory::createProfileWindow() {

return new QtContactEditWindow();

}

}

#pragma once

#include <QObject>

#include <Swift/Controllers/UIInterfaces/UIFactory.h>

class QtMainWindow;

class QtChatTheme;

class QtChatWindowFactory;

class QtUIFactory : public QObject, public UIFactory {

Q_OBJECT

virtual MUCSearchWindow* createMUCSearchWindow();

virtual ChatWindow* createChatWindow(const JID &contact, UIEventStream* eventStream);

virtual UserSearchWindow* createUserSearchWindow(UserSearchWindow::Type type, UIEventStream* eventStream, const std::set<std::string>& groups);

virtual ProfileWindow* createProfileWindow();

virtual ContactEditWindow* createContactEditWindow();

private slots:

void handleLoginWindowGeometryChanged();

private:

QtSettingsProvider* settings;

QtChatWindowFactory* chatWindowFactory;

QtMainWindow* lastMainWindow;

QtLoginWindow* loginWindow;

bool startMinimized;

};

}

}

void QtWebView::contextMenuEvent(QContextMenuEvent* ev) {

// Filter out the relevant actions from the standard actions

QMenu* menu = page()->createStandardContextMenu();

QList<QAction*> actions(menu->actions());

for (int i = 0; i < actions.size(); ++i) {

QAction* action = actions.at(i);

if (removeAction) {

menu->removeAction(action);

}

// Add our own custom actions

menu->addAction(tr("Clear"), this, SIGNAL(clearRequested()));

menu->exec(ev->globalPos());

delete menu;

void keyPressEvent(QKeyEvent* event);

void dragEnterEvent(QDragEnterEvent *event);

void contextMenuEvent(QContextMenuEvent* ev);

signals:

void gotFocus();

void clearRequested();

protected:

void focusInEvent(QFocusEvent* event);

private:

std::vector<QWebPage::WebAction> filteredActions;

};

}

emit titleUpdated();

}

void QtXMLConsoleWidget::showEvent(QShowEvent* event) {

emit windowOpening();

emit titleUpdated(); /* This just needs to be somewhere after construction */

event->accept();

}

}

}

void QtXMLConsoleWidget::appendTextIfEnabled(const std::string& data, const QColor& color) {

public:

QtXMLConsoleWidget();

void show();

void activate();

private:

virtual void closeEvent(QCloseEvent* event);

#include "DelegateCommons.h"

namespace Swift {

QString adjustedText(painter->fontMetrics().elidedText(text, Qt::ElideRight, region.width(), Qt::TextShowMnemonic));

}

const int DelegateCommons::horizontalMargin = 2;

const int DelegateCommons::verticalMargin = 2;

const int DelegateCommons::farLeftMargin = 2;

#include <QPainter>

#include <QRect>

#include <QString>

namespace Swift {

class DelegateCommons {

detailFont.setPointSize(nameFont.pointSize() - detailFontSizeDrop);

}

int detailFontSizeDrop;

QFont nameFont;

static const int horizontalMargin;

static const int verticalMargin;

static const int farLeftMargin;

};

}

#include "Roster/QtTreeWidget.h"

#include <boost/smart_ptr/make_shared.hpp>

#include "Swiften/Base/Platform.h"

#include "Swift/Controllers/Roster/ContactRosterItem.h"

#include "Swift/Controllers/Roster/GroupRosterItem.h"

#include "Swift/Controllers/UIEvents/UIEventStream.h"

#include "Swift/Controllers/UIEvents/RequestChatUIEvent.h"

#include "QtSwiftUtil.h"

namespace Swift {

eventStream_ = eventStream;

model_ = new RosterModel(this);

setModel(model_);

expandAll();

setAnimated(true);

setIndentation(0);

setRootIsDecorated(true);

connect(this, SIGNAL(activated(const QModelIndex&)), this, SLOT(handleItemActivated(const QModelIndex&)));

connect(model_, SIGNAL(itemExpanded(const QModelIndex&, bool)), this, SLOT(handleModelItemExpanded(const QModelIndex&, bool)));

}

void QtTreeWidget::currentChanged(const QModelIndex& current, const QModelIndex& previous) {

QModelIndexList selectedIndexList = getSelectedIndexes();

/* I didn't quite understand why using current didn't seem to work here.*/

}

else if (current.isValid()) {

}

QTreeView::currentChanged(current, previous);

}

void QtTreeWidget::handleItemActivated(const QModelIndex& index) {

RosterItem* item = static_cast<RosterItem*>(index.internalPointer());

ContactRosterItem* contact = dynamic_cast<ContactRosterItem*>(item);

}

}

}

}

QModelIndex index = indexAt(event->pos());

}

}

}

}

}

}

void QtTreeWidget::handleExpanded(const QModelIndex& index) {

#include <QTreeView>

#include <QModelIndex>

#include "Swift/QtUI/Roster/RosterModel.h"

#include "Swift/QtUI/Roster/RosterDelegate.h"

QtTreeWidgetItem* getRoot();

void setRosterModel(Roster* roster);

Roster* getRoster() {return roster_;}

private slots:

void handleItemActivated(const QModelIndex&);

void handleCollapsed(const QModelIndex&);

void handleClicked(const QModelIndex&);

protected:

private:

void drawBranches(QPainter*, const QRect&, const QModelIndex&) const;

private:

RosterModel* model_;

Roster* roster_;

RosterDelegate* delegate_;

QtTreeWidgetItem* treeRoot_;

};

}

#include <QBrush>

#include <QFontMetrics>

#include <QPainterPath>

#include <QPolygon>

#include <qdebug.h>

#include <QBitmap>

#include "QtTreeWidget.h"

#include "RosterModel.h"

namespace Swift {

return contactSizeHint(option, index);

}

}

void RosterDelegate::paint(QPainter* painter, const QStyleOptionViewItem& option, const QModelIndex& index) const {

}

void RosterDelegate::paintContact(QPainter* painter, const QStyleOptionViewItem& option, const QModelIndex& index) const {

if (index.data(AvatarRole).isValid() && !index.data(AvatarRole).value<QString>().isNull()) {

}

QIcon presenceIcon = index.data(PresenceIconRole).isValid() && !index.data(PresenceIconRole).value<QIcon>().isNull()

}

}

DelegateCommons common_;

GroupItemDelegate* groupDelegate_;

QtTreeWidget* tree_;

};

}

myenv.MergeFlags(env["SWIFTOOLS_FLAGS"])

if myenv["HAVE_XSS"] :

myenv.MergeFlags(env["XSS_FLAGS"])

if myenv["HAVE_SPARKLE"] :

myenv.MergeFlags(env["SPARKLE_FLAGS"])

myenv.MergeFlags(env["SWIFTEN_FLAGS"])

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

myenv.MergeFlags(myenv["GROWL_FLAGS"])

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

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

myenv.Append(LIBS = "qtmain")

sources = [

"main.cpp",

"QtStatusWidget.cpp",

"QtScaledAvatarCache.cpp",

"QtSwift.cpp",

"QtChatView.cpp",

"QtChatTheme.cpp",

"QtChatTabs.cpp",

"QtTabWidget.cpp",

"QtTextEdit.cpp",

"QtXMLConsoleWidget.cpp",

"QtUtilities.cpp",

"QtBookmarkDetailWindow.cpp",

"QtAddBookmarkWindow.cpp",

"MessageSnippet.cpp",

"SystemMessageSnippet.cpp",

"QtElidingLabel.cpp",

"QtLineEdit.cpp",

"QtJoinMUCWindow.cpp",

"Roster/RosterModel.cpp",

"Roster/RosterDelegate.cpp",

"Roster/GroupItemDelegate.cpp",

"Roster/DelegateCommons.cpp",

"EventViewer/EventModel.cpp",

"EventViewer/EventDelegate.cpp",

"EventViewer/TwoLineDelegate.cpp",

"ChatList/ChatListModel.cpp",

"ChatList/ChatListDelegate.cpp",

"ChatList/ChatListMUCItem.cpp",

"MUCSearch/QtMUCSearchWindow.cpp",

"MUCSearch/MUCSearchModel.cpp",

"MUCSearch/MUCSearchRoomItem.cpp",

"QtWebView.cpp",

"qrc_DefaultTheme.cc",

"qrc_Swift.cc",

]

myenv["SWIFT_VERSION"] = Version.getBuildVersion(env.Dir("#").abspath, "swift")

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

sources += [

"WindowsNotifier.cpp",

]

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

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

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

else :

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

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

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

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

# Resources

commonResources = {

}

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

# Collect available languages

translation_languages = []

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

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

# Generate translation modules

translation_modules = []

for lang in translation_languages :

translation_sources.append(env.File(translation_source).abspath)

translation_modules.append(env.File(translation_resource).abspath)

myenv.Qm(translation_resource, translation_source)

frameworks.append(env["SPARKLE_FRAMEWORK"])

if env["HAVE_GROWL"] :

frameworks.append(env["GROWL_FRAMEWORK"])

if env["DIST"] :

myenv.Command(["Swift-${SWIFT_VERSION}.dmg"], [app], ["Swift/Packaging/MacOSX/package.sh " + app.path + " Swift/Packaging/MacOSX/Swift.dmg.gz $TARGET $QTDIR"])

if env.get("SWIFT_INSTALLDIR", "") :

icons_path = os.path.join(env["SWIFT_INSTALLDIR"], "share", "icons", "hicolor")

for i in ["16", "22", "24", "64", "128"] :

for dir, resource in commonResources.items() :

env.Install(os.path.join(env["SWIFT_INSTALLDIR"], "share", "swift", dir), resource)

commonResources[""] = commonResources.get("", []) + [

os.path.join(env["OPENSSL_DIR"], "bin", "ssleay32.dll"),

os.path.join(env["OPENSSL_DIR"], "bin", "libeay32.dll"),

]

myenv.WindowsBundle("Swift",

resources = commonResources,

boost::program_options::variables_map vm;

try {

boost::program_options::store(boost::program_options::parse_command_line(argc, argv, desc), vm);

#if BOOST_VERSION >= 104200

std::cout << "Ignoring unknown option " << option.get_option_name() << " but continuing." << std::endl;

#else