else {

if (appendToPrevious) {

content_ = theme->getOutgoingNextContent();

}

else {

content_ = theme->getOutgoingContent();

}

}

content_.replace("%sender%", escape(sender));

content_.replace("%time%", "<span class='swift_time'>" + timeToEscapedString(time) + "</span>");

content_.replace("%userIconPath%", escape(iconURI));

content_ = "<div id='" + id + "'>" + content_ + "</div>";

}

MessageSnippet::~MessageSnippet() {

}

void QtChatView::setAckXML(const QString& id, const QString& xml) {

QWebElement message = document_.findFirst("#" + id);

/* Deliberately not asserting here, so that when we start expiring old messages it won't hit us */

if (message.isNull()) return;

QWebElement ackElement = message.findFirst("span.swift_ack");

assert(!ackElement.isNull());

ackElement.setInnerXml(xml);

}

void QtChatView::rememberScrolledToBottom() {

isAtBottom_ = webPage_->mainFrame()->scrollBarValue(Qt::Vertical) == webPage_->mainFrame()->scrollBarMaximum(Qt::Vertical);

}

void QtChatView::scrollToBottom() {

isAtBottom_ = true;

webPage_->mainFrame()->setScrollBarValue(Qt::Vertical, webPage_->mainFrame()->scrollBarMaximum(Qt::Vertical));

webView_->update(); /* Work around redraw bug in some versions of Qt. */

}

public:

QtChatView(QtChatTheme* theme, QWidget* parent);

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

void addLastSeenLine();

void replaceLastMessage(const QString& newMessage);

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

void replaceMessage(const QString& newMessage, const QString& id, const QDateTime& time);

void rememberScrolledToBottom();

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

QString getLastSentMessage();

void addToJSEnvironment(const QString&, QObject*);

void setFileTransferProgress(QString id, const int percentageDone);

void setFileTransferStatus(QString id, const ChatWindow::FileTransferState state, const QString& msg);

signals:

void gotFocus();

void fontResized(int);

}

void QtChatWindow::flash() {

emit requestFlash();

}

void QtChatWindow::setAckState(std::string const& id, ChatWindow::AckState state) {

QString xml;

switch (state) {

case ChatWindow::Failed: xml = "<img src='qrc:/icons/error.png' alt='" + tr("This message may not have been transmitted.") + "'/>"; break;

}

messageLog_->setAckXML(P2QSTRING(id), xml);

}

int QtChatWindow::getCount() {

return unreadCount_;

}

std::string QtChatWindow::addAction(const std::string &message, const std::string &senderName, bool senderIsSelf, boost::shared_ptr<SecurityLabel> label, const std::string& avatarPath, const boost::posix_time::ptime& time) {

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

}

std::string formatSize(const boost::uintmax_t bytes) {

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

void setInputEnabled(bool enabled);

QtTabbable::AlertType getWidgetAlertState();

void setContactChatState(ChatState::ChatStateType state);

void setRosterModel(Roster* roster);

void setTabComplete(TabComplete* completer);

int getCount();

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

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

void flash();

QByteArray getSplitterState();

virtual void setAvailableOccupantActions(const std::vector<OccupantAction>& actions);

void setSubject(const std::string& subject);

void showRoomConfigurationForm(Form::ref);

void addMUCInvitation(const JID& jid, const std::string& reason, const std::string& password);

void setAffiliations(MUCOccupant::Affiliation, const std::vector<JID>&);

public slots:

window()->hide();

#endif

}

}

void QtLoginWindow::hide() {

window()->hide();

}

void QtLoginWindow::resizeEvent(QResizeEvent*) {

emit geometryChanged();

}

void QtLoginWindow::moveEvent(QMoveEvent*) {

emit geometryChanged();

}

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

class QLabel;

class QToolButton;

class QComboBox;

namespace Swift {

class QtLoginWindow : public QMainWindow, public LoginWindow {

Q_OBJECT

public:

QtLoginWindow(UIEventStream* uiEventStream, bool eagleMode);

void morphInto(MainWindow *mainWindow);

virtual void loggedOut();

virtual void setMessage(const std::string& message);

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

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

virtual void quit();

signals:

void geometryChanged();

private slots:

void loginClicked();

void handleCertficateChecked(bool);

void handleQuit();

#include <QMenuBar>

#include <QToolBar>

#include <QAction>

#include <QTabWidget>

#include <Swift/QtUI/QtSwiftUtil.h>

#include <Swift/QtUI/QtTabWidget.h>

#include <Swift/QtUI/QtSettingsProvider.h>

#include <Swift/QtUI/QtUIPreferences.h>

#include <Roster/QtRosterWidget.h>

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

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

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

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

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

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

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

namespace Swift {

#define CURRENT_ROSTER_TAB "current_roster_tab"

uiEventStream_ = uiEventStream;

uiPreferences_ = uiPreferences;

settings_ = settings;

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

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

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

mainLayout->setSpacing(0);

meView_ = new QtRosterHeader(settings, this);

mainLayout->addWidget(meView_);

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

actionsMenu->addAction(chatUserAction_);

serverAdHocMenu_ = new QMenu(tr("Run Server Command"), this);

actionsMenu->addMenu(serverAdHocMenu_);

actionsMenu->addSeparator();

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

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

actionsMenu->addAction(signOutAction);

treeWidget_->onSomethingSelectedChanged.connect(boost::bind(&QAction::setEnabled, editUserAction_, _1));

setAvailableAdHocCommands(std::vector<DiscoItems::Item>());

QAction* adHocAction = new QAction(tr("Collecting commands..."), this);

adHocAction->setEnabled(false);

serverAdHocMenu_->addAction(adHocAction);

serverAdHocCommandActions_.append(adHocAction);

lastOfflineState_ = false;

QtMainWindow::~QtMainWindow() {

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

}

void QtMainWindow::handleTabChanged(int index) {

settings_->storeInt(CURRENT_ROSTER_TAB, index);

}

QtEventWindow* QtMainWindow::getEventWindow() {

return eventWindow_;

}

QtChatListWindow* QtMainWindow::getChatListWindow() {

return chatListWindow_;

}

void QtMainWindow::setRosterModel(Roster* roster) {

uiEventStream_->send(event);

}

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

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

uiEventStream_->send(event);

}

void QtMainWindow::handleSignOutAction() {

onSignOutRequest();

}

void QtMainWindow::handleEditProfileAction() {

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

}

void QtMainWindow::handleJoinMUCAction() {

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

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

onChangeStatusRequest(showType, Q2PSTRING(statusMessage));

}

void QtMainWindow::handleUIEvent(boost::shared_ptr<UIEvent> event) {

boost::shared_ptr<ToggleShowOfflineUIEvent> toggleEvent = boost::dynamic_pointer_cast<ToggleShowOfflineUIEvent>(event);

if (toggleEvent) {

handleShowOfflineToggled(toggleEvent->getShow());

}

}

void QtMainWindow::handleShowOfflineToggled(bool state) {

if (state != lastOfflineState_) {

lastOfflineState_ = state;

showOfflineAction_->setChecked(state);

uiEventStream_->onUIEvent(boost::shared_ptr<UIEvent>(new ToggleShowOfflineUIEvent(state)));

}

}

#pragma once

#include <QWidget>

#include <QMenu>

#include <QList>

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

#include "Swift/QtUI/QtRosterHeader.h"

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

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

#include <vector>

class QComboBox;

class QLineEdit;

class QPushButton;

class QToolBar;

class QAction;

class QMenu;

class TreeWidget;

class UIEventStream;

class QtTabWidget;

class QtSettingsProvider;

class QtUIPreferences;

class QtMainWindow : public QWidget, public MainWindow {

Q_OBJECT

public:

virtual ~QtMainWindow();

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

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

void setMyJID(const JID& jid);

void setMyAvatarPath(const std::string& path);

void setMyStatusText(const std::string& status);

void setMyStatusType(StatusShow::Type type);

void setConnecting();

QtEventWindow* getEventWindow();

void handleSignOutAction();

void handleEditProfileAction();

void handleAddUserActionTriggered(bool checked);

void handleChatUserActionTriggered(bool checked);

void handleAdHocActionTriggered(bool checked);

void handleEventCountUpdated(int count);

void handleChatCountUpdated(int count);

void handleEditProfileRequest();

void handleTabChanged(int index);

private:

QtSettingsProvider* settings_;

std::vector<QMenu*> menus_;

QtRosterWidget* treeWidget_;

QtRosterHeader* meView_;

QAction* addUserAction_;

QAction* editUserAction_;

QAction* chatUserAction_;

QAction* showOfflineAction_;

QMenu* serverAdHocMenu_;

QtTabWidget* tabs_;

QWidget* contactsTabWidget_;

QWidget* eventsTabWidget_;

QtEventWindow* eventWindow_;

QtChatListWindow* chatListWindow_;

UIEventStream* uiEventStream_;

bool lastOfflineState_;

std::vector<DiscoItems::Item> serverAdHocCommands_;

tabs->addTab(widget);

if (!tabs->isVisible()) {

tabs->show();

}

widget->show();

return widget;

}

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

return lastMainWindow;

}

LoginWindow* QtUIFactory::createLoginWindow(UIEventStream* eventStream) {

loginWindow = new QtLoginWindow(eventStream, eagleMode);

if (netbookSplitter) {

netbookSplitter->insertWidget(0, loginWindow);

}

connect(systemTray, SIGNAL(clicked()), loginWindow, SLOT(bringToFront()));

<file alias="logo-chat-16.png">../resources/logo/logo-chat-16.png</file>

<file alias="logo-shaded-text.256.png">../resources/logo/logo-shaded-text.256.png</file>

<file alias="icons/online.png">../resources/icons/online.png</file>

<file alias="icons/connecting.mng">../resources/icons/connecting.mng</file>

<file alias="icons/away.png">../resources/icons/away.png</file>

<file alias="icons/dnd.png">../resources/icons/dnd.png</file>

<file alias="icons/offline.png">../resources/icons/offline.png</file>

<file alias="icons/certificate.png">../resources/icons/certificate.png</file>

<file alias="icons/error.png">../resources/icons/error.png</file>

<file alias="icons/throbber.gif">../resources/icons/throbber.gif</file>

<file alias="icons/avatar.png">../resources/icons/avatar.png</file>

<file alias="icons/no-avatar.png">../resources/icons/no-avatar.png</file>

<file alias="icons/tray-standard.png">../resources/icons/tray-standard.png</file>

<file alias="icons/new-chat.png">../resources/icons/new-chat.png</file>

<file alias="icons/actions.png">../resources/icons/actions.png</file>

<file alias="COPYING">../../COPYING</file>

</qresource>

</RCC>