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

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

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

#include <Swiften/Avatars/AvatarManager.h>

#include <Swiften/Elements/Delay.h>

#include <Swiften/MUC/MUC.h>

chatWindow_->setTabComplete(completer_);

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

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

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

delete completer_;

}

void MUCController::handleBareJIDCapsChanged(const JID& /*jid*/) {

ChatWindow::Tristate support = ChatWindow::Yes;

bool any = false;

#include <Swiften/JID/JID.h>

#include <Swiften/MUC/MUC.h>

#include <Swiften/Elements/MUCOccupant.h>

namespace Swift {

class StanzaChannel;

class IQRouter;

class ChatWindowFactory;

class Roster;

class AvatarManager;

private:

void clearPresenceQueue();

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

void handleWindowClosed();

void handleAvatarChanged(const JID& jid);

void handleOccupantJoined(const MUCOccupant& occupant);

class TreeWidget;

class Roster;

class TabComplete;

class ChatWindow {

public:

enum AckState {Pending, Received, Failed};

enum Tristate {Yes, No, Maybe};

ChatWindow() {}

virtual ~ChatWindow() {};

*/

virtual void cancelAlert() = 0;

boost::signal<void ()> onClosed;

boost::signal<void ()> onAllMessagesRead;

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

boost::signal<void ()> onUserTyping;

boost::signal<void ()> onUserCancelsTyping;

boost::signal<void ()> onAlertButtonClicked;

};

}

#endif

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

virtual void cancelAlert() {};

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

boost::signal<void ()> onClosed;

boost::signal<void ()> onAllMessagesRead;

#include "QtChatWindow.h"

#include "QtSwiftUtil.h"

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

#include "SwifTools/Linkify.h"

#include "QtChatView.h"

#include "MessageSnippet.h"

messageLog_ = new QtChatView(theme, this);

logRosterSplitter_->addWidget(messageLog_);

treeWidget_->hide();

logRosterSplitter_->addWidget(treeWidget_);

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

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

resize(400,300);

connect(messageLog_, SIGNAL(fontResized(int)), this, SIGNAL(fontResized(int)));

}

}

void QtChatWindow::handleFontResized(int fontSizeSteps) {

messageLog_->resizeFont(fontSizeSteps);

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

}

}

namespace Swift {

class QtChatView;

class QtChatTheme;

class TreeWidget;

class QtTextEdit;

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

void flash();

QByteArray getSplitterState();

public slots:

void handleChangeSplitterState(QByteArray state);

void handleKeyPressEvent(QKeyEvent* event);

void handleSplitterMoved(int pos, int index);

void handleAlertButtonClicked();

private:

void updateTitleWithUnreadCount();

void tabComplete();

void beginCorrection();

void cancelCorrection();

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

QtChatTheme* theme_;

QtTextEdit* input_;

QComboBox* labelsWidget_;

QLabel* correctingLabel_;

QLabel* alertLabel_;

QWidget* alertWidget_;

contactTabLayout->setSpacing(0);

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

contactTabLayout->addWidget(treeWidget_);

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

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

actionsMenu->addAction(signOutAction);

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

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

#include <QContextMenuEvent>

#include <QMenu>

#include <QInputDialog>

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

}

void QtOccupantListWidget::contextMenuEvent(QContextMenuEvent* event) {

}

}

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

namespace Swift {

class QtOccupantListWidget : public QtTreeWidget {

public:

QtOccupantListWidget(UIEventStream* eventStream, QWidget* parent = 0);

virtual ~QtOccupantListWidget();

protected:

void contextMenuEvent(QContextMenuEvent* event);

};

}

}

}

}

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

namespace Swift {

class QtRosterWidget : public QtTreeWidget {

Q_OBJECT

public:

virtual ~QtRosterWidget();

public slots:

void handleEditUserActionTriggered(bool checked);

protected:

void contextMenuEvent(QContextMenuEvent* event);

private:

void renameGroup(GroupRosterItem* group);

};

return selectedIndexList;

}

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

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

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

QtTreeWidgetItem* getRoot();

void setRosterModel(Roster* roster);

Roster* getRoster() {return roster_;}

private slots:

void handleItemActivated(const QModelIndex&);

QModelIndexList getSelectedIndexes() const;

private:

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

protected:

UIEventStream* eventStream_;