chatWindow_->onDestroyRequest.connect(boost::bind(&MUCController::handleDestroyRoomRequest, this));

chatWindow_->onInviteToChat.connect(boost::bind(&MUCController::handleInvitePersonToThisMUCRequest, this, _1));

chatWindow_->onGetAffiliationsRequest.connect(boost::bind(&MUCController::handleGetAffiliationsRequest, this));

chatWindow_->onChangeAffiliationsRequest.connect(boost::bind(&MUCController::handleChangeAffiliationsRequest, this, _1));

muc_->onJoinComplete.connect(boost::bind(&MUCController::handleJoinComplete, this, _1));

muc_->onJoinFailed.connect(boost::bind(&MUCController::handleJoinFailed, this, _1));

muc_->onOccupantJoined.connect(boost::bind(&MUCController::handleOccupantJoined, this, _1));

muc_->onOccupantPresenceChange.connect(boost::bind(&MUCController::handleOccupantPresenceChange, this, _1));

muc_->onOccupantLeft.connect(boost::bind(&MUCController::handleOccupantLeft, this, _1, _2, _3));

muc_->onRoleChangeFailed.connect(boost::bind(&MUCController::handleOccupantRoleChangeFailed, this, _1, _2, _3));

muc_->onAffiliationListReceived.connect(boost::bind(&MUCController::handleAffiliationListReceived, this, _1, _2));

muc_->onConfigurationFailed.connect(boost::bind(&MUCController::handleConfigurationFailed, this, _1));

muc_->onConfigurationFormReceived.connect(boost::bind(&MUCController::handleConfigurationFormReceived, this, _1));

highlighter_->setMode(Highlighter::MUCMode);

highlighter_->setNick(nick_);

if (timerFactory) {

loginCheckTimer_ = boost::shared_ptr<Timer>(timerFactory->createTimer(MUC_JOIN_WARNING_TIMEOUT_MILLISECONDS));

loginCheckTimer_->onTick.connect(boost::bind(&MUCController::handleJoinTimeoutTick, this));

loginCheckTimer_->start();

}

if (isImpromptu) {

muc_->onUnlocked.connect(boost::bind(&MUCController::handleRoomUnlocked, this));

} else {

chatWindow_->setName(muc->getJID().getNode());

}

setOnline(true);

if (avatarManager_ != NULL) {

avatarChangedConnection_ = (avatarManager_->onAvatarChanged.connect(boost::bind(&MUCController::handleAvatarChanged, this, _1)));

}

handleBareJIDCapsChanged(muc->getJID());

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

}

lastWasPresence_ = false;

}

void MUCController::handleWindowOccupantSelectionChanged(ContactRosterItem* item) {

std::vector<ChatWindow::OccupantAction> actions;

if (item) {

MUCOccupant::Affiliation affiliation = muc_->getOccupant(getNick()).getAffiliation();

MUCOccupant::Role role = muc_->getOccupant(getNick()).getRole();

{

if (affiliation == MUCOccupant::Admin || affiliation == MUCOccupant::Owner) {

actions.push_back(ChatWindow::Ban);

}

actions.push_back(ChatWindow::Kick);

actions.push_back(ChatWindow::MakeModerator);

actions.push_back(ChatWindow::MakeParticipant);

actions.push_back(ChatWindow::MakeVisitor);

chatWindow_->addSystemMessage(chatMessageParser_->parseMessageBody(joinMessage), ChatWindow::DefaultDirection);

#ifdef SWIFT_EXPERIMENTAL_HISTORY

addRecentLogs();

#endif

clearPresenceQueue();

shouldJoinOnReconnect_ = true;

setEnabled(true);

onUserJoined();

if (isImpromptu_) {

setImpromptuWindowTitle();

}

}

void MUCController::handleAvatarChanged(const JID& jid) {

if (parting_ || !jid.equals(toJID_, JID::WithoutResource)) {

receivedActivity();

JID jid(nickToJID(occupant.getNick()));

JID realJID;

if (occupant.getRealJID()) {

realJID = occupant.getRealJID().get();

}

currentOccupants_.insert(occupant.getNick());

NickJoinPart event(occupant.getNick(), Join);

appendToJoinParts(joinParts_, event);

roster_->addContact(jid, realJID, occupant.getNick(), groupName, avatarManager_->getAvatarPath(jid));

if (joined_) {

std::string joinString;

if (role != MUCOccupant::NoRole && role != MUCOccupant::Participant) {

joinString = str(format(QT_TRANSLATE_NOOP("", "%1% has entered the %3% as a %2%.")) % occupant.getNick() % roleToFriendlyName(role) % (isImpromptu_ ? QT_TRANSLATE_NOOP("", "chat") : QT_TRANSLATE_NOOP("", "room")));

}

else {

joinString = str(format(QT_TRANSLATE_NOOP("", "%1% has entered the %2%.")) % occupant.getNick() % (isImpromptu_ ? QT_TRANSLATE_NOOP("", "chat") : QT_TRANSLATE_NOOP("", "room")));

}

if (shouldUpdateJoinParts()) {

updateJoinParts();

} else {

enum AckState {Pending, Received, Failed};

enum ReceiptState {ReceiptRequested, ReceiptReceived, ReceiptFailed};

enum Tristate {Yes, No, Maybe};

enum OccupantAction {Kick, Ban, MakeModerator, MakeParticipant, MakeVisitor, AddContact, ShowProfile};

enum RoomAction {ChangeSubject, Configure, Affiliations, Destroy, Invite};

enum FileTransferState {WaitingForAccept, Negotiating, Transferring, Canceled, Finished, FTFailed};

enum WhiteboardSessionState {WhiteboardAccepted, WhiteboardTerminated, WhiteboardRejected};

enum BlockingState {BlockingUnsupported, IsBlocked, IsUnblocked};

enum Direction { UnknownDirection, DefaultDirection };

ChatWindow() {}

virtual ~ChatWindow() {}

/** Add message to window.

* @return id of added message (for acks).

*/

virtual std::string addMessage(const ChatMessage& message, const std::string& senderName, bool senderIsSelf, boost::shared_ptr<SecurityLabel> label, const std::string& avatarPath, const boost::posix_time::ptime& time, const HighlightAction& highlight) = 0;

/** Adds action to window.

virtual void setContactChatState(ChatState::ChatStateType state) = 0;

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

virtual void show() = 0;

virtual void activate() = 0;

virtual void setAvailableSecurityLabels(const std::vector<SecurityLabelsCatalog::Item>& labels) = 0;

virtual void setSecurityLabelsEnabled(bool enabled) = 0;

virtual void setCorrectionEnabled(Tristate enabled) = 0;

virtual void setUnreadMessageCount(int count) = 0;

// virtual TreeWidget *getTreeWidget() = 0;

virtual void setSecurityLabelsError() = 0;

virtual SecurityLabelsCatalog::Item getSelectedSecurityLabel() = 0;

virtual void setInputEnabled(bool enabled) = 0;

virtual void setRosterModel(Roster* model) = 0;

virtual void setTabComplete(TabComplete* completer) = 0;

virtual void replaceLastMessage(const ChatMessage& message) = 0;

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

virtual void flash() = 0;

virtual void setMessageReceiptState(const std::string &/* id */, ReceiptState /* state */) { }

virtual void setContactChatState(ChatState::ChatStateType /*state*/) {}

virtual void setName(const std::string& name) {name_ = name;}

virtual void show() {}

virtual void activate() {}

virtual void setAvailableSecurityLabels(const std::vector<SecurityLabelsCatalog::Item>& labels) {labels_ = labels;}

virtual void setSecurityLabelsEnabled(bool enabled) {labelsEnabled_ = enabled;}

virtual void setUnreadMessageCount(int /*count*/) {}

virtual void setSecurityLabelsError() {}

virtual SecurityLabelsCatalog::Item getSelectedSecurityLabel() {return label_;}

virtual void setInputEnabled(bool /*enabled*/) {}

virtual void setRosterModel(Roster* roster) { roster_ = roster; }

Roster* getRosterModel() { return roster_; }

virtual void setTabComplete(TabComplete*) {}

void setAckState(const std::string& /*id*/, AckState /*state*/) {}

virtual void flash() {}

layout->addWidget(logRosterSplitter_);

if (settings_->getSetting(QtUISettingConstants::USE_PLAIN_CHATS) || settings_->getSetting(QtUISettingConstants::USE_SCREENREADER)) {

messageLog_ = new QtPlainChatView(this, eventStream_);

}

else {

messageLog_ = new QtWebKitChatView(this, eventStream_, theme, this); // I accept that passing the ChatWindow in so that the view can call the signals is somewhat inelegant, but it saves a lot of boilerplate. This patch is unpleasant enough already. So let's fix this soon (it at least needs fixing by the time history is sorted), but not now.

}

logRosterSplitter_->addWidget(messageLog_);

treeWidget_->hide();

logRosterSplitter_->addWidget(treeWidget_);

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

connect(logRosterSplitter_, SIGNAL(splitterMoved(int, int)), this, SLOT(handleSplitterMoved(int, int)));

midBar_ = new QWidget(this);

//layout->addWidget(midBar);

midBar_->setAutoFillBackground(true);

QHBoxLayout *midBarLayout = new QHBoxLayout(midBar_);

return labelModel_->availableLabels_[labelsWidget_->currentIndex()];

}

void QtChatWindow::closeEvent(QCloseEvent* event) {

event->accept();

emit windowClosing();

onClosed();

}

isMUC_ = true;

treeWidget_->show();

subject_->setVisible(!impromptu_);

}

void QtChatWindow::qAppFocusChanged(QWidget* /*old*/, QWidget* /*now*/) {

if (isWidgetSelected()) {

lastLineTracker_.setHasFocus(true);

input_->setFocus();

void setFileTransferProgress(std::string id, const int percentageDone);

void setFileTransferStatus(std::string id, const FileTransferState state, const std::string& msg);

std::string addWhiteboardRequest(bool senderIsSelf);

void setWhiteboardSessionStatus(std::string id, const ChatWindow::WhiteboardSessionState state);

void show();

void activate();

void setUnreadMessageCount(int count);

// TreeWidget *getTreeWidget();

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

void setSecurityLabelsEnabled(bool enabled);

void setSecurityLabelsError();

SecurityLabelsCatalog::Item getSelectedSecurityLabel();

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

void setInputEnabled(bool enabled);

QtTabbable::AlertType getWidgetAlertState();

void setContactChatState(ChatState::ChatStateType state);

QSizePolicy sizePolicy(QSizePolicy::Expanding, QSizePolicy::Preferred);

sizePolicy.setHorizontalStretch(80);

sizePolicy.setVerticalStretch(0);

conversation_->setSizePolicy(sizePolicy);

ui_.conversation_ = conversation_;

ui_.bottomLayout_->addWidget(conversation_);

delete ui_.conversationRoster_;

QSizePolicy sizePolicy2(QSizePolicy::Preferred, QSizePolicy::Expanding);

sizePolicy2.setVerticalStretch(80);

conversationRoster_->setSizePolicy(sizePolicy2);

ui_.conversationRoster_ = conversationRoster_;

ui_.bottomLeftLayout_->setDirection(QBoxLayout::BottomToTop);

ui_.bottomLeftLayout_->addWidget(conversationRoster_);

setWindowTitle(tr("History"));

/*

* Licensed under the GNU General Public License v3.

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

*/

#include <QContextMenuEvent>

#include <QMenu>

#include <QAction>

#include <QInputDialog>

namespace Swift {

}

QtOccupantListWidget::~QtOccupantListWidget() {

}

void QtOccupantListWidget::setAvailableOccupantActions(const std::vector<ChatWindow::OccupantAction>& actions) {

availableOccupantActions_ = actions;

/*

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

namespace Swift {

class SettingsProvider;

class QtOccupantListWidget : public QtTreeWidget {

Q_OBJECT

public:

virtual ~QtOccupantListWidget();

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

boost::signal<void (ChatWindow::OccupantAction, ContactRosterItem*)> onOccupantActionSelected;

protected:

void contextMenuEvent(QContextMenuEvent* event);

private:

std::vector<ChatWindow::OccupantAction> availableOccupantActions_;

};

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

#include <Swift/QtUI/QtContactEditWindow.h>

#include <Swift/Controllers/Roster/ContactRosterItem.h>

#include <Swift/Controllers/Roster/GroupRosterItem.h>

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

#include <Swift/QtUI/QtSwiftUtil.h>

namespace Swift {

}

QtRosterWidget::~QtRosterWidget() {

}

void QtRosterWidget::handleEditUserActionTriggered(bool /*checked*/) {

QModelIndexList selectedIndexList = getSelectedIndexes();

#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 <Swift/Controllers/UIEvents/SendFileUIEvent.h>

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

#include <Swift/QtUI/QtUISettingConstants.h>

#include <QtSwiftUtil.h>

namespace Swift {

eventStream_ = eventStream;

settings_ = settings;

model_ = new RosterModel(this, settings_->getSetting(QtUISettingConstants::USE_SCREENREADER));

setModel(model_);

delegate_ = new RosterDelegate(this, settings_->getSetting(QtUISettingConstants::COMPACT_ROSTER));

setItemDelegate(delegate_);

setHeaderHidden(true);

#ifdef SWIFT_PLATFORM_MACOSX

setAlternatingRowColors(true);

}

else if (current.isValid()) {

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

item = dynamic_cast<ContactRosterItem*>(item);

}

onSomethingSelectedChanged(item);

QTreeView::currentChanged(current, previous);

}

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

}

}

void QtTreeWidget::dragEnterEvent(QDragEnterEvent *event) {

if (event->mimeData()->hasUrls() && event->mimeData()->urls().size() == 1) {

event->acceptProposedAction();

}

}

}

void QtTreeWidget::drawBranches(QPainter*, const QRect&, const QModelIndex&) const {

}

void QtTreeWidget::show() {

QWidget::show();

}

}

/*

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include <QDragEnterEvent>

#include <QDropEvent>

#include <QDragMoveEvent>

#include <Swift/QtUI/Roster/RosterDelegate.h>

namespace Swift {

class UIEventStream;

class SettingsProvider;

Q_OBJECT

public:

~QtTreeWidget();

void show();

QtTreeWidgetItem* getRoot();

void setRosterModel(Roster* roster);

Roster* getRoster() {return roster_;}

void refreshTooltip();

boost::signal<void (RosterItem*)> onSomethingSelectedChanged;

private slots:

void handleItemActivated(const QModelIndex&);

void handleModelItemExpanded(const QModelIndex&, bool expanded);

void handleExpanded(const QModelIndex&);

void handleCollapsed(const QModelIndex&);

void handleClicked(const QModelIndex&);

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

void handleRefreshTooltip();

protected:

void dragEnterEvent(QDragEnterEvent* event);

void dropEvent(QDropEvent* event);

void dragMoveEvent(QDragMoveEvent* event);

bool event(QEvent* event);

QModelIndexList getSelectedIndexes() const;

private:

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

protected slots:

virtual void currentChanged(const QModelIndex& current, const QModelIndex& previous);

protected:

UIEventStream* eventStream_;

private:

RosterModel* model_;

Roster* roster_;

RosterDelegate* delegate_;

QtTreeWidgetItem* treeRoot_;

SettingsProvider* settings_;

bool tooltipShown_;

};

}

case Qt::DisplayRole: return getScreenReaderTextOr(item, P2QSTRING(item->getDisplayName()));

case Qt::TextColorRole: return getTextColor(item);

case Qt::BackgroundColorRole: return getBackgroundColor(item);

case Qt::ToolTipRole: return getToolTip(item);

case StatusTextRole: return getStatusText(item);

case AvatarRole: return getAvatar(item);

case PresenceIconRole: return getPresenceIcon(item);

case ChildCountRole: return getChildCount(item);

case IdleRole: return getIsIdle(item);

default: return QVariant();

}

}

QString RosterModel::getScreenReaderTextOr(RosterItem* item, const QString& alternative) const {

QString name = P2QSTRING(item->getDisplayName());

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

if (contact && screenReader_) {

name += ": " + P2QSTRING(statusShowTypeToFriendlyName(contact->getStatusShow()));

return P2QSTRING(pathToString(contact->getAvatarPath()));

}

QString RosterModel::getStatusText(RosterItem* item) const {

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

if (!contact) return "";

return P2QSTRING(contact->getStatusText());

}

QIcon RosterModel::getPresenceIcon(RosterItem* item) const {

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

if (!contact) return QIcon();

if (contact->blockState() == ContactRosterItem::IsBlocked ||

contact->blockState() == ContactRosterItem::IsDomainBlocked) {

return QIcon(":/icons/stop.png");

}

return QIcon(statusShowTypeToIconPath(contact->getStatusShow()));

#include <Swift/QtUI/QtScaledAvatarCache.h>

namespace Swift {

enum RosterRoles {

StatusTextRole = Qt::UserRole,

AvatarRole = Qt::UserRole + 1,

PresenceIconRole = Qt::UserRole + 2,

StatusShowTypeRole = Qt::UserRole + 3,

ChildCountRole = Qt::UserRole + 4,

};

class QtTreeWidget;

class RosterModel : public QAbstractItemModel {

Q_OBJECT

public:

RosterModel(QtTreeWidget* view, bool screenReaderMode);

~RosterModel();

void handleDataChanged(RosterItem* item);

void handleChildrenChanged(GroupRosterItem* item);

RosterItem* getItem(const QModelIndex& index) const;

QColor intToColor(int color) const;

QColor getTextColor(RosterItem* item) const;

QColor getBackgroundColor(RosterItem* item) const;

QString getToolTip(RosterItem* item) const;

QString getAvatar(RosterItem* item) const;

QString getStatusText(RosterItem* item) const;

QIcon getPresenceIcon(RosterItem* item) const;

int getChildCount(RosterItem* item) const;

bool getIsIdle(RosterItem* item) const;

void reLayout();

/** calculates screenreader-friendly text if in screenreader mode, otherwise uses alternative text */

QString getScreenReaderTextOr(RosterItem* item, const QString& alternative) const;

private:

Roster* roster_;

QtTreeWidget* view_;