roster_ = new Roster(false, true);

completer_ = new TabComplete();

chatWindow_->setRosterModel(roster_);

chatWindow_->setTabComplete(completer_);

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

chatWindow_->onClosed.connect(boost::bind(&MUCController::handleWindowClosed, this));

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

chatWindow_->onOccupantActionSelected.connect(boost::bind(&MUCController::handleActionRequestedOnOccupant, this, _1, _2));

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_->onOccupantRoleChanged.connect(boost::bind(&MUCController::handleOccupantRoleChanged, this, _1, _2, _3));

if (timerFactory) {

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

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

completer_->addWord(nick);

}

}

/*Buggy implementations never send the status code, so use an incoming message as a hint that joining's done (e.g. the old ejabberd on psi-im.org).*/

receivedActivity();

joined_ = true;

if (!message->getSubject().empty() && message->getBody().empty()) {

chatWindow_->addSystemMessage(str(format(QT_TRANSLATE_NOOP("", "The room subject is now: %1%")) % message->getSubject()));;

doneGettingHistory_ = true;

}

if (!doneGettingHistory_ && !message->getPayload<Delay>()) {

doneGettingHistory_ = true;

}

if (!doneGettingHistory_) {

messageEvent->conclude();

} else {

result += QT_TRANSLATE_NOOP("", " and ");

}

}

result += eventStrings[populatedEvents[i]];

}

return result;

}

}

void handleWindowClosed();

void handleAvatarChanged(const JID& jid);

void handleOccupantJoined(const MUCOccupant& occupant);

void handleOccupantLeft(const MUCOccupant& occupant, MUC::LeavingType type, const std::string& reason);

void handleOccupantPresenceChange(boost::shared_ptr<Presence> presence);

void handleOccupantRoleChanged(const std::string& nick, const MUCOccupant& occupant,const MUCOccupant::Role& oldRole);

void handleJoinComplete(const std::string& nick);

void handleJoinFailed(boost::shared_ptr<ErrorPayload> error);

void handleJoinTimeoutTick();

std::string roleToGroupName(MUCOccupant::Role role);

std::string roleToSortName(MUCOccupant::Role role);

JID nickToJID(const std::string& nick);

std::string roleToFriendlyName(MUCOccupant::Role role);

void receivedActivity();

bool messageTargetsMe(boost::shared_ptr<Message> message);

void updateJoinParts();

bool shouldUpdateJoinParts();

void dayTicked() {lastWasPresence_ = false;}

// 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 std::string& message) = 0;

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

virtual void flash() = 0;

/**

* Set an alert on the window.

* @param alertText Description of alert (required).

* @param buttonText Button text to use (optional, no button is shown if empty).

*/

virtual void setAlert(const std::string& alertText, const std::string& buttonText = "") = 0;

/**

* Removes an alert.

*/

boost::signal<void ()> onClosed;

boost::signal<void ()> onAllMessagesRead;

boost::signal<void (const std::string&, bool isCorrection)> onSendMessageRequest;

boost::signal<void ()> onSendCorrectionMessageRequest;

boost::signal<void ()> onUserTyping;

boost::signal<void ()> onUserCancelsTyping;

boost::signal<void ()> onAlertButtonClicked;

boost::signal<void (ContactRosterItem*)> onOccupantSelectionChanged;

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

// File transfer related

boost::signal<void (std::string /* id */)> onFileTransferCancel;

boost::signal<void (std::string /* id */, std::string /* description */)> onFileTransferStart;

boost::signal<void (std::string /* id */, std::string /* path */)> onFileTransferAccept;

boost::signal<void (std::string /* path */)> onSendFileRequest;

};

}

#endif

virtual void setTabComplete(TabComplete*) {};

virtual void replaceLastMessage(const std::string&) {};

virtual void replaceMessage(const std::string&, const std::string&, const boost::posix_time::ptime&) {};

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

virtual void flash() {};

virtual void setAlert(const std::string& /*alertText*/, const std::string& /*buttonText*/) {};

virtual void cancelAlert() {};

virtual void setCorrectionEnabled(Tristate /*enabled*/) {}

void setAvailableOccupantActions(const std::vector<OccupantAction>&/* actions*/) {}

boost::signal<void ()> onClosed;

boost::signal<void ()> onAllMessagesRead;

boost::signal<void (const std::string&, bool isCorrection)> onSendMessageRequest;

std::string name_;

std::string lastMessageBody_;

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

bool labelsEnabled_;

#include <QFileInfo>

#include <QLineEdit>

#include <QSplitter>

#include <QString>

#include <QTextEdit>

#include <QTime>

#include <QUrl>

#include <QPushButton>

#include <QFileDialog>

#include <QDebug>

namespace Swift {

QtChatWindow::QtChatWindow(const QString &contact, QtChatTheme* theme, UIEventStream* eventStream) : QtTabbable(), contact_(contact), previousMessageWasSelf_(false), previousMessageWasSystem_(false), previousMessageWasPresence_(false), previousMessageWasFileTransfer_(false), eventStream_(eventStream) {

unreadCount_ = 0;

inputEnabled_ = true;

completer_ = NULL;

theme_ = theme;

connect (alertButton_, SIGNAL(clicked()), this, SLOT(handleAlertButtonClicked()));

alertLayout->addWidget(alertButton_);

QPalette palette = alertWidget_->palette();

palette.setColor(QPalette::Window, QColor(Qt::yellow));

palette.setColor(QPalette::WindowText, QColor(Qt::black));

alertWidget_->setStyleSheet(alertStyleSheet_);

alertLabel_->setStyleSheet(alertStyleSheet_);

alertWidget_->hide();

logRosterSplitter_ = new QSplitter(this);

logRosterSplitter_->setAutoFillBackground(true);

layout->addWidget(logRosterSplitter_);

messageLog_ = new QtChatView(theme, this);

logRosterSplitter_->addWidget(messageLog_);

treeWidget_ = new QtOccupantListWidget(eventStream_, this);

treeWidget_->hide();

logRosterSplitter_->addWidget(treeWidget_);

void QtChatWindow::closeEvent(QCloseEvent* event) {

event->accept();

emit windowClosing();

onClosed();

}

void QtChatWindow::convertToMUC() {

setAcceptDrops(false);

treeWidget_->show();

}

if (isWidgetSelected()) {

lastLineTracker_.setHasFocus(true);

input_->setFocus();

onAllMessagesRead();

}

else {

lastLineTracker_.setHasFocus(false);

}

}

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

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

}

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

treeWidget_->setAvailableOccupantActions(actions);

}

}

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

public slots:

void handleChangeSplitterState(QByteArray state);

void handleFontResized(int fontSizeSteps);

void setAlert(const std::string& alertText, const std::string& buttonText = "");

void cancelAlert();

void setCorrectionEnabled(Tristate enabled);

signals:

protected:

void showEvent(QShowEvent* event);

private slots:

void returnPressed();

void handleInputChanged();

void handleKeyPressEvent(QKeyEvent* event);

void handleSplitterMoved(int pos, int index);

void handleAlertButtonClicked();

void handleFileTransferCancel(QString id);

void handleFileTransferSetDescription(QString id);

void handleFileTransferStart(QString id);

void handleFileTransferAccept(QString id, QString filename);

private:

void updateTitleWithUnreadCount();

QtChatTheme* theme_;

QtTextEdit* input_;

QComboBox* labelsWidget_;

QtOccupantListWidget* treeWidget_;

QLabel* correctingLabel_;

QLabel* alertLabel_;

QWidget* alertWidget_;

QPushButton* alertButton_;

TabComplete* completer_;

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

bool isCorrection_;

bool previousMessageWasSelf_;

bool previousMessageWasSystem_;

bool previousMessageWasPresence_;

bool previousMessageWasFileTransfer_;

QString previousSenderName_;

bool inputClearing_;

UIEventStream* eventStream_;