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

};

}

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

namespace Swift {

class ChatListMUCItem : public ChatListItem {

public:

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

const MUCBookmark& getBookmark();

QVariant data(int role) const;

/*

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

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

boost::shared_ptr<UIEvent> event(new JoinMUCUIEvent(mucItem->getBookmark().getRoom(), mucItem->getBookmark().getNick()));

eventStream_->send(event);

}

}

}

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

model_->removeMUCBookmark(bookmark);

}

void QtChatListWindow::handleRemoveBookmark() {

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

if (!mucItem) return;

/*

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

#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() {

//qApp->processEvents();

}

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

assert(viewReady_);

/* FIXME: must be queued? */

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

}

void QtChatView::copySelectionToClipboard() {

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

webPage_->triggerAction(QWebPage::Copy);

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

QtChatTheme* theme_;

QWebElement newInsertPoint_;

QWebElement lastElement_;

QWebElement document_;

};

inputEnabled_ = true;

completer_ = NULL;

theme_ = theme;

updateTitleWithUnreadCount();

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

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

layout->setSpacing(2);

QSplitter *logRosterSplitter = new QSplitter(this);

logRosterSplitter->setAutoFillBackground(true);

input_ = new QtTextEdit(this);

input_->setAcceptRichText(false);

layout->addWidget(input_);

inputClearing_ = false;

contactIsTyping_ = false;

void QtChatWindow::handleKeyPressEvent(QKeyEvent* event) {

int key = event->key();

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

if (key == Qt::Key_W && modifiers == Qt::ControlModifier) {

close();

} else if (

emit requestActiveTab();

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

tabComplete();

} else {

messageLog_->handleKeyPressEvent(event);

}

}

void QtChatWindow::setRosterModel(Roster* roster) {

}

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

Q_UNUSED(old);

Q_UNUSED(now);

if (isWidgetSelected()) {

input_->setFocus();

onAllMessagesRead();

}

}

void QtChatWindow::setInputEnabled(bool enabled) {

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;

htmlString += styleSpanStart + messageHTML + styleSpanEnd;

bool appendToPrevious = !previousMessageWasSystem_ && !previousMessageWasPresence_ && ((senderIsSelf && previousMessageWasSelf_) || (!senderIsSelf && !previousMessageWasSelf_ && previousSenderName_ == P2QSTRING(senderName)));

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

previousMessageWasPresence_ = false;

}

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

if (isWidgetSelected()) {

onAllMessagesRead();

return;

}

messageLog_->scrollToBottom();

inputClearing_ = true;

input_->clear();

inputClearing_ = false;

}

void QtChatWindow::moveEvent(QMoveEvent*) {

}

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

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

*/

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

#include "QtTabbable.h"

#include "Swiften/Base/IDGenerator.h"

class QTextEdit;

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

int unreadCount_;

bool contactIsTyping_;

QString contact_;

QtChatView* messageLog_;

QtChatTheme* theme_;

QtTextEdit* input_;

QtTreeWidget* treeWidget_;

TabComplete* completer_;

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

bool previousMessageWasSelf_;

bool previousMessageWasSystem_;

bool previousMessageWasPresence_;

IDGenerator id_;

};

}

/*

* Licensed under the GNU General Public License v3.

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

*/

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

}

void QtLoginWindow::loggedOut() {

setInitialMenus();

setIsLoggingIn(false);

}

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>

private:

void setInitialMenus();

QStringList usernames_;

QStringList passwords_;

QStringList certificateFiles_;

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

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

connect(treeWidget_, SIGNAL(onSomethingSelectedChanged(bool)), editUserAction_, SLOT(setEnabled(bool)));

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) {

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 {

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

QtTreeWidget* treeWidget_;

QtRosterHeader* meView_;

QAction* editUserAction_;

QAction* chatUserAction_;

QAction* showOfflineAction_;

QtTabWidget* tabs_;

QWidget* contactsTabWidget_;

QWidget* eventsTabWidget_;

QtChatListWindow* chatListWindow_;

UIEventStream* uiEventStream_;

bool lastOfflineState_;

};

}

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

dock_ = new NullDock();

#endif

if (splitter_) {

splitter_->show();

}

certificateStorageFactory_,

dock_,

notifier_,

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

mainControllers_.push_back(mainController);

}

}

delete tabs_;

delete splitter_;

delete dock_;

delete soundPlayer_;

delete chatWindowFactory_;

class QtMUCSearchWindowFactory;

class QtUserSearchWindowFactory;

class EventLoop;

class QtSwift : public QObject {

Q_OBJECT

QSplitter* splitter_;

QtSoundPlayer* soundPlayer_;

Dock* dock_;

QtChatTabs* tabs_;

ApplicationPathProvider* applicationPathProvider_;

StoragesFactory* storagesFactory_;

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

return new QtContactEditWindow();

}

}

virtual JoinMUCWindow* createJoinMUCWindow();

virtual ProfileWindow* createProfileWindow();

virtual ContactEditWindow* createContactEditWindow();

private slots:

void handleLoginWindowGeometryChanged();

"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",

"ChatList/ChatListModel.cpp",

"ChatList/ChatListDelegate.cpp",

"ChatList/ChatListMUCItem.cpp",

"MUCSearch/QtMUCSearchWindow.cpp",

"MUCSearch/MUCSearchModel.cpp",

"MUCSearch/MUCSearchRoomItem.cpp",

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

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

sources += [

"WindowsNotifier.cpp",

"../resources/Windows/Swift.res"

]

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

if env["HAVE_GROWL"] :

frameworks.append(env["GROWL_FRAMEWORK"])

commonResources[""] = commonResources.get("", []) + ["../resources/MacOSX/Swift.icns"]

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", "") :

env.InstallAs(os.path.join(env["SWIFT_INSTALLDIR"], "share", "pixmaps", "swift.xpm"), "../resources/logo/logo-icon-32.xpm")

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

env.InstallAs(os.path.join(icons_path, "32x32", "apps", "swift.xpm"), "../resources/logo/logo-icon-32.xpm")