/* http://www.sublimetext.com/docs/2/projects.html */

{

"folders":

[

{

"path": "..",

"file_exclude_patterns": [".cproject", ".project", ".sconsign.dblite", "*~", "config.log", "*.o"]

}

],

"settings":

{

"tab_size": 4,

"translate_tabs_to_spaces": false

}

chatWindow_->onInvitePersonToThisMUCRequest.connect(boost::bind(&MUCController::handleInvitePersonToThisMUCRequest, 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));

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

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

if (timerFactory) {

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

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

loginCheckTimer_->start();

}

chatWindow_->convertToMUC();

setOnline(true);

if (avatarManager_ != NULL) {

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

if (loginCheckTimer_) {

loginCheckTimer_->stop();

}

chatWindow_->setTabComplete(NULL);

delete completer_;

}

void MUCController::handleWindowOccupantSelectionChanged(ContactRosterItem* item) {

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

if (item) {

actions.push_back(ChatWindow::Kick);

}

chatWindow_->setAvailableOccupantActions(actions);

}

void MUCController::handleActionRequestedOnOccupant(ChatWindow::OccupantAction action, ContactRosterItem* item) {

switch (action) {

}

}

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

ChatWindow::Tristate support = ChatWindow::Yes;

bool any = false;

foreach (const std::string& nick, currentOccupants_) {

DiscoInfo::ref disco = entityCapsProvider_->getCaps(toJID_.toBare().toString() + "/" + nick);

if (disco && disco->hasFeature(DiscoInfo::MessageCorrectionFeature)) {

}

}

void MUCController::handleConfigurationFailed(ErrorPayload::ref error) {

std::string errorMessage = getErrorMessage(error);

errorMessage = str(format(QT_TRANSLATE_NOOP("", "Room configuration failed: %1%.")) % errorMessage);

chatWindow_->addErrorMessage(errorMessage);

}

void MUCController::handleConfigurationFormReceived(Form::ref form) {

chatWindow_->showRoomConfigurationForm(form);

}

void MUCController::handleConfigurationCancelled() {

muc_->cancelConfigureRoom();

}

void MUCController::handleDestroyRoomRequest() {

void dayTicked() {lastWasPresence_ = false;}

void processUserPart();

void handleBareJIDCapsChanged(const JID& jid);

void handleConfigureRequest(Form::ref);

void handleConfigurationFailed(ErrorPayload::ref);

void handleConfigurationFormReceived(Form::ref);

void handleDestroyRoomRequest();

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

void handleConfigurationCancelled();

private:

MUC::ref muc_;

UIEventStream* events_;

std::string nick_;

std::string desiredNick_;

Roster* roster_;

TabComplete* completer_;

bool parting_;

class TabComplete;

class RosterItem;

class ContactRosterItem;

class FileTransferController;

class ChatWindow {

public:

enum AckState {Pending, Received, Failed};

enum Tristate {Yes, No, Maybe};

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

ChatWindow() {}

virtual ~ChatWindow() {};

/** Add message to window.

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

*/

virtual std::string addMessage(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) = 0;

/** Adds action to window.

}

}

void QtChatWindow::setCorrectionEnabled(Tristate enabled) {

correctionEnabled_ = enabled;

}

SecurityLabelsCatalog::Item QtChatWindow::getSelectedSecurityLabel() {

assert(labelsWidget_->isEnabled());

return availableLabels_[labelsWidget_->currentIndex()];

}

void QtChatWindow::closeEvent(QCloseEvent* event) {

event->accept();

emit windowClosing();

onClosed();

}

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

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

if (contact) {

QMenu contextMenu;

std::map<QAction*, ChatWindow::OccupantAction> actions;

foreach (ChatWindow::OccupantAction availableAction, availableOccupantActions_) {

QString text = "Error: missing string";

switch (availableAction) {

case ChatWindow::Kick: text = tr("Kick user"); break;

}

QAction* action = contextMenu.addAction(text);

actions[action] = availableAction;

}

QAction* result = contextMenu.exec(event->globalPos());

if (result) {

onOccupantActionSelected(actions[result], contact);

}

}

#include <Swiften/Elements/SecurityLabel.h>

namespace Swift {

class SecurityLabelsCatalog : public Payload {

public:

typedef boost::shared_ptr<SecurityLabelsCatalog> ref;

class Item {

public:

Item() : default_(false) {}

return label_;

}

label_ = label;

}

const std::string& getSelector() const { return selector_; }

void setSelector(const std::string& selector) {

selector_ = selector;

}

bool getIsDefault() const { return default_; }

void setIsDefault(bool isDefault) {

default_ = isDefault;

}

private:

std::string selector_;

bool default_;

};

SecurityLabelsCatalog(const JID& to = JID()) : to_(to) {}

const std::vector<Item>& getItems() const {

return items_;

}

bool MUC::hasOccupant(const std::string& nick) {

return occupants.find(nick) != occupants.end();

}

MUCOccupant MUC::getOccupant(const std::string& nick) {

return occupants.find(nick)->second;

}

MUCAdminPayload::ref mucPayload = boost::make_shared<MUCAdminPayload>();

MUCItem item;

item.nick = jid.getResource();

mucPayload->addItem(item);

GenericRequest<MUCAdminPayload>* request = new GenericRequest<MUCAdminPayload>(IQ::Set, getJID(), mucPayload, iqRouter_);

request->send();

}

if (error) {

}

}

void MUC::changeSubject(const std::string& subject) {

Message::ref message = boost::make_shared<Message>();

message->setSubject(subject);

message->setType(Message::Groupchat);

message->setTo(ownMUCJID.toBare());

stanzaChannel->sendMessage(message);

/*void queryRoomItems(); */

std::string getCurrentNick();

void part();

void handleIncomingMessage(Message::ref message);

/** Expose public so it can be called when e.g. user goes offline */

void handleUserLeft(LeavingType);

/** Get occupant information*/

MUCOccupant getOccupant(const std::string& nick);

bool hasOccupant(const std::string& nick);

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

void requestConfigurationForm();

void configureRoom(Form::ref);

void cancelConfigureRoom();

void destroyRoom();

/** Send an invite for the person to join the MUC */

void invitePerson(const JID& person, const std::string& reason = "");

void setCreateAsReservedIfNew() {createAsReservedIfNew = true;}

void setPassword(const boost::optional<std::string>& password);

public:

boost::signal<void (const std::string& /*nick*/)> onJoinComplete;

boost::signal<void (ErrorPayload::ref)> onJoinFailed;

boost::signal<void (ErrorPayload::ref)> onConfigurationFailed;

boost::signal<void (Presence::ref)> onOccupantPresenceChange;

boost::signal<void (const std::string&, const MUCOccupant& /*now*/, const MUCOccupant::Role& /*old*/)> onOccupantRoleChanged;

boost::signal<void (const std::string&, const MUCOccupant::Affiliation& /*new*/, const MUCOccupant::Affiliation& /*old*/)> onOccupantAffiliationChanged;

boost::signal<void (const MUCOccupant&)> onOccupantJoined;

boost::signal<void (const MUCOccupant&, LeavingType, const std::string& /*reason*/)> onOccupantLeft;

boost::signal<void (Form::ref)> onConfigurationFormReceived;

/* boost::signal<void (const MUCInfo&)> onInfoResult; */

/* boost::signal<void (const blah&)> onItemsResult; */

const std::string& getOwnNick() const {

return ownMUCJID.getResource();

}

private:

void handleIncomingPresence(Presence::ref presence);

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

void handleCreationConfigResponse(MUCOwnerPayload::ref, ErrorPayload::ref);

void handleConfigurationFormReceived(MUCOwnerPayload::ref, ErrorPayload::ref);

void handleConfigurationResultReceived(MUCOwnerPayload::ref, ErrorPayload::ref);

private:

JID ownMUCJID;

StanzaChannel* stanzaChannel;

IQRouter* iqRouter_;

DirectedPresenceSender* presenceSender;

MUCRegistry* mucRegistry;