public:

AdHocController(AdHocCommandWindowFactory* factory, std::shared_ptr<OutgoingAdHocCommandSession> command);

~AdHocController();

void setOnline(bool online);

private:

void handleWindowClosed();

* See the COPYING file for more information.

*/

#include <vector>

#include <Swiften/Elements/DiscoInfo.h>

#include <Swiften/Elements/DiscoItems.h>

#include <Swiften/Elements/ErrorPayload.h>

#include <Swift/Controllers/AdHocController.h>

namespace Swift {

class IQRouter;

private:

void handleServerDiscoItemsResponse(std::shared_ptr<DiscoItems>, ErrorPayload::ref error);

void handleUIEvent(std::shared_ptr<UIEvent> event);

JID jid_;

IQRouter* iqRouter_;

UIEventStream* uiEventStream_;

std::string lastWbID_;

ClientBlockListManager* clientBlockListManager_;

boost::optional<ChatWindow::AlertID> deliveryReceiptAlert_;

boost::optional<ChatWindow::AlertID> blockedContactAlert_;

#include <boost/date_time/posix_time/posix_time.hpp>

#include <boost/filesystem/path.hpp>

#include <boost/optional.hpp>

#include <Swiften/Base/IDGenerator.h>

#include <Swiften/Elements/DiscoInfo.h>

#include <Swiften/Elements/ErrorPayload.h>

#include <Swiften/Elements/SecurityLabelsCatalog.h>

class ChatMessageParser;

class AutoAcceptMUCInviteDecider;

public:

virtual ~ChatControllerBase();

void showChatWindow();

void setEnabled(bool enabled);

virtual void setToJID(const JID& jid) {toJID_ = jid;}

/** Used for determining when something is recent.*/

int getUnreadCount();

const JID& getToJID() {return toJID_;}

void handleCapsChanged(const JID& jid);

void setCanStartImpromptuChats(bool supportsImpromptu);

virtual ChatWindow* detachChatWindow();

protected:

ChatControllerBase(const JID& self, StanzaChannel* stanzaChannel, IQRouter* iqRouter, ChatWindowFactory* chatWindowFactory, const JID &toJID, PresenceOracle* presenceOracle, AvatarManager* avatarManager, bool useDelayForLatency, UIEventStream* eventStream, EventController* eventController, TimerFactory* timerFactory, EntityCapsProvider* entityCapsProvider, HistoryController* historyController, MUCRegistry* mucRegistry, HighlightManager* highlightManager, std::shared_ptr<ChatMessageParser> chatMessageParser, AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider);

std::vector<ChatListWindow::Chat> getRecentChats() const;

virtual std::vector<Contact::ref> getContacts(bool withMUCNicks);

private:

class SingleChatWindowFactoryAdapter : public ChatWindowFactory {

std::shared_ptr<DiscoInfo> serverDiscoInfo_;

ChatListWindow* chatListWindow_;

JoinMUCWindow* joinMUCWindow_;

bool useDelayForLatency_;

TimerFactory* timerFactory_;

MUCRegistry* mucRegistry_;

#include <set>

#include <string>

#include <Swiften/Base/Override.h>

#include <Swiften/Elements/DiscoInfo.h>

#include <Swiften/Elements/MUCOccupant.h>

#include <Swiften/Elements/Message.h>

public:

MUCController(const JID& self, MUC::ref muc, const boost::optional<std::string>& password, const std::string &nick, StanzaChannel* stanzaChannel, IQRouter* iqRouter, ChatWindowFactory* chatWindowFactory, PresenceOracle* presenceOracle, AvatarManager* avatarManager, UIEventStream* events, bool useDelayForLatency, TimerFactory* timerFactory, EventController* eventController, EntityCapsProvider* entityCapsProvider, XMPPRoster* roster, HistoryController* historyController, MUCRegistry* mucRegistry, HighlightManager* highlightManager, ClientBlockListManager* clientBlockListManager, std::shared_ptr<ChatMessageParser> chatMessageParser, bool isImpromptu, AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider, VCardManager* vcardManager, MUCBookmarkManager* mucBookmarkManager);

virtual ~MUCController();

virtual void setOnline(bool online) SWIFTEN_OVERRIDE;

virtual void setAvailableServerFeatures(std::shared_ptr<DiscoInfo> info) SWIFTEN_OVERRIDE;

void rejoin();

bool lastWasPresence_;

bool shouldJoinOnReconnect_;

bool doneGettingHistory_;

std::shared_ptr<Timer> loginCheckTimer_;

std::set<std::string> currentOccupants_;

std::vector<NickJoinPart> joinParts_;

std::string lastJoinMessageUID_;

ClientBlockListManager* clientBlockListManager_;

boost::optional<ChatWindow::AlertID> blockedContactAlert_;

MUCBookmarkManager* mucBookmarkManager_;

};

}

#include <string>

#include <vector>

#include <Swiften/Elements/DiscoInfo.h>

#include <Swiften/Elements/DiscoItems.h>

#include <Swiften/Elements/ErrorPayload.h>

void openSearchWindow();

public:

private:

void handleSearchService(const JID& jid);

#include <string>

#include <vector>

#include <Swiften/Elements/DiscoInfo.h>

#include <Swiften/Elements/DiscoItems.h>

#include <Swiften/Elements/ErrorPayload.h>

#include <memory>

#include <Swiften/JID/JID.h>

#include <Swift/Controllers/XMPPEvents/StanzaEvent.h>

EventNotifier(EventController* eventController, Notifier* notifier, AvatarManager* avatarManager, NickResolver* nickResolver);

~EventNotifier();

private:

void handleEventAdded(std::shared_ptr<StanzaEvent>);

EventController* eventController_;

EventWindowFactory* windowFactory_;

EventWindow* window_;

};

}

#include <boost/bind.hpp>

#include <boost/filesystem.hpp>

#include <Swiften/Base/Log.h>

#include <Swiften/FileTransfer/FileReadBytestream.h>

#include <Swiften/FileTransfer/FileTransferManager.h>

#include <Swiften/FileTransfer/OutgoingJingleFileTransfer.h>

int getProgress() const;

boost::uintmax_t getSize() const;

private:

void handleFileTransferStateChange(FileTransfer::State);

#include <boost/bind.hpp>

#include <boost/filesystem.hpp>

#include <Swiften/Base/Log.h>

#include <Swiften/Base/foreach.h>

#include <Swiften/FileTransfer/FileTransferManager.h>

*/

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#include <vector>

#include <Swift/Controllers/FileTransfer/FileTransferController.h>

void clearFinished();

bool isClearable() const;

private:

void handleIncomingFileTransfer(IncomingFileTransfer::ref transfer);

#pragma once

#include <boost/cstdint.hpp>

namespace Swift {

void setBytesProcessed(int processedBytes);

int getPercentage() const;

private:

boost::uintmax_t completeBytes;

#include <Swift/Controllers/HighlightManager.h>

#include <cassert>

#include <boost/algorithm/string.hpp>

#include <boost/archive/text_iarchive.hpp>

#include <string>

#include <vector>

#include <Swift/Controllers/HighlightRule.h>

void storeSettings();

void loadSettings();

private:

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

bool storingSettings_;

std::shared_ptr<HighlightManager::HighlightRulesList> rules_;

};

typedef std::shared_ptr<const HighlightManager::HighlightRulesList> HighlightRulesListPtr;

*/

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#include <vector>

#include <boost/date_time/posix_time/posix_time.hpp>

#include <Swiften/History/HistoryMessage.h>

#include <Swiften/History/HistoryStorage.h>

boost::posix_time::ptime getLastTimeStampFromMUC(const JID& selfJID, const JID& mucJID);

private:

HistoryStorage* localHistory_;

#include <set>

#include <boost/bind.hpp>

#include <Swiften/History/HistoryStorage.h>

#include <Swiften/JID/JID.h>

#include <Swiften/Presence/PresenceOracle.h>

#include <string>

#include <vector>

#include <Swiften/Client/ClientError.h>

#include <Swiften/Client/ClientXMLTracer.h>

#include <Swiften/Elements/CapsInfo.h>

#include <memory>

#include <set>

#include <Swiften/Avatars/AvatarManager.h>

#include <Swiften/Elements/Presence.h>

#include <Swiften/JID/JID.h>

#include <Swiften/Network/Timer.h>

void setInitialQuietPeriodMS(int ms);

private:

void handlePresenceReceived(std::shared_ptr<Presence>);

#include <boost/bind.hpp>

#include <boost/date_time/posix_time/ptime.hpp>

#include <boost/filesystem/path.hpp>

#include <Swiften/Elements/MUCOccupant.h>

#include <Swiften/Elements/Presence.h>

#include <Swiften/Elements/StatusShow.h>

VCard::ref getVCard() const;

void setVCard(VCard::ref vcard);

private:

JID jid_;

GroupRosterItem* removeGroupChild(const std::string& group);

void removeAll();

void setDisplayed(RosterItem* item, bool displayed);

static bool itemLessThanWithStatus(const RosterItem* left, const RosterItem* right);

static bool itemLessThanWithoutStatus(const RosterItem* left, const RosterItem* right);

void setExpanded(bool expanded);

bool isExpanded() const;

void setManualSort(const std::string& manualSortValue);

virtual const std::string& getSortableDisplayName() const;

private:

#include <string>

#include <vector>

#include <Swiften/JID/JID.h>

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

std::set<JID> getJIDs() const;

std::vector<RosterFilter*> getFilters() {return filters_;}

GroupRosterItem* getGroup(const std::string& groupName);

void setBlockingSupported(bool isSupported);

#include <set>

#include <string>

#include <Swiften/Avatars/AvatarManager.h>

#include <Swiften/Elements/ErrorPayload.h>

#include <Swiften/Elements/Presence.h>

#include <Swiften/Elements/RosterPayload.h>

void showRosterWindow();

void setJID(const JID& jid) { myJID_ = jid; }

MainWindow* getWindow() {return mainWindow_;}

void handleOwnVCardChanged(VCard::ref vcard);

void handleAvatarChanged(const JID& jid);

void handlePresenceChanged(Presence::ref presence);

RosterVCardProvider* rosterVCardProvider_;

std::shared_ptr<ContactRosterItem> ownContact_;

};

}

#include <memory>

#include <string>

namespace Swift {

class GroupRosterItem;

public:

RosterItem(const std::string& name, GroupRosterItem* parent);

virtual ~RosterItem();

GroupRosterItem* getParent() const;

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

const std::string& getDisplayName() const;

* See Documentation/Licenses/BSD-simplified.txt for more information.

*/

#pragma once

#include <Swiften/Elements/VCard.h>

#include <Swiften/JID/JID.h>

Roster* roster_;

VCardManager* vcardManager_;

JID::CompareType compareType_;

};

}

#include <vector>

#include <boost/filesystem/path.hpp>

#include <Swiften/Elements/StatusShow.h>

#include <Swiften/JID/JID.h>

const Item& getItem(const Index&) const;

private:

void handleUpdateTimerTick();

#include <string>

#include <vector>

namespace Swift {

/**

* Emitted when a setting is changed.

*/

};

}

#include <memory>

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

namespace Swift {

class UIEventStream {

public:

void send(std::shared_ptr<UIEvent> event) {

onUIEvent(event);

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

namespace Swift {

class AdHocCommandWindow {

public:

virtual ~AdHocCommandWindow() {}

virtual void setOnline(bool /*online*/) {}

};

}

#include <vector>

#include <Swiften/JID/JID.h>

namespace Swift {

virtual std::vector<JID> getCurrentBlockList() const = 0;

};

}

#include <set>

#include <boost/filesystem/path.hpp>

#include <Swiften/Base/foreach.h>

#include <Swiften/Elements/StatusShow.h>

#include <Swiften/MUC/MUCBookmark.h>

virtual void clearBookmarks() = 0;

virtual void setOnline(bool isOnline) = 0;

};

}

#include <boost/algorithm/string.hpp>

#include <boost/date_time/posix_time/posix_time.hpp>

#include <boost/optional.hpp>

#include <Swiften/Base/Tristate.h>

#include <Swiften/Elements/ChatState.h>

#include <Swiften/Elements/Form.h>

#include <Swiften/Elements/MUCOccupant.h>

*/

virtual void showRoomConfigurationForm(Form::ref) = 0;

// File transfer related

//Whiteboard related

// Blocking Command related

};

}

#include <string>

#include <vector>

namespace Swift {

class JID;

virtual void show() = 0;

virtual void hide() = 0;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#include <vector>

#include <Swift/Controllers/Contact.h>

namespace Swift {

virtual void setContactSuggestions(const std::vector<Contact::ref>& suggestions) = 0;

public:

};

}

* See Documentation/Licenses/BSD-simplified.txt for more information.

*/

#pragma once

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

virtual std::string getSearchBoxText() = 0;

virtual boost::gregorian::date getLastVisibleDate() = 0;

};

}

#include <string>

#include <vector>

#include <Swiften/JID/JID.h>

namespace Swift {

virtual void setMUC(const std::string& nick) = 0;

virtual void show() = 0;

};

}

#include <memory>

#include <string>

#include <Swiften/Client/ClientOptions.h>

#include <Swiften/TLS/Certificate.h>

#include <Swiften/TLS/CertificateWithKey.h>

virtual void addAvailableAccount(const std::string& defaultJID, const std::string& defaultPassword, const std::string& defaultCertificate, const ClientOptions& options) = 0;

virtual void removeAvailableAccount(const std::string& jid) = 0;

/** The certificate is what is used for login, the certificatePath is used for remembering paths to populate the loginwindow with*/

virtual void setLoginAutomatically(bool loginAutomatically) = 0;

virtual void quit() = 0;

/** Blocking request whether a cert should be permanently trusted.*/

virtual bool askUserToTrustCertificatePermanently(const std::string& message, const std::vector<Certificate::ref>& certificateChain) = 0;

};

}

#include <vector>

#include <boost/optional.hpp>

#include <Swiften/JID/JID.h>

#include <Swift/Controllers/Chat/MUCSearchController.h>

virtual void show() = 0;

};

}

#include <memory>

#include <string>

#include <Swiften/Elements/DiscoItems.h>

#include <Swiften/Elements/StatusShow.h>

#include <Swiften/JID/JID.h>

virtual void setStreamEncryptionStatus(bool tlsInPlaceAndValid) = 0;

virtual void openCertificateDialog(const std::vector<Certificate::ref>& chain) = 0;

private:

bool canDelete_;

#include <memory>

#include <Swiften/Elements/VCard.h>

namespace Swift {

virtual void show() = 0;

virtual void hide() = 0;

};

}

#include <string>

#include <vector>

#include <Swiften/JID/JID.h>

#include <Swift/Controllers/Chat/UserSearchController.h>

virtual void show() = 0;

};

}

#include <string>

namespace Swift {

class WhiteboardSession;

WhiteboardWindow* createNewWhiteboardWindow(const JID& contact, WhiteboardSession::ref session);

public:

private:

void handleUIEvent(std::shared_ptr<UIEvent> event);

WhiteboardWindowFactory* whiteboardWindowFactory_;

UIEventStream* uiEventStream_;

NickResolver* nickResolver_;

WhiteboardSessionManager* whiteboardSessionManager_;

};

}

#include <memory>

#include <boost/bind.hpp>

#include <Swiften/Base/SafeByteArray.h>

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

#include <memory>

#include <string>

#include <Swiften/JID/JID.h>

#include <Swift/Controllers/XMPPEvents/StanzaEvent.h>

#include <memory>

#include <vector>

#include <Swift/Controllers/XMPPEvents/MessageEvent.h>

#include <Swift/Controllers/XMPPEvents/StanzaEvent.h>

~EventController();

void handleIncomingEvent(std::shared_ptr<StanzaEvent> sourceEvent);

const EventList& getEvents() const {return events_;}

void disconnectAll();

void clear();

#include <memory>

#include <boost/date_time/posix_time/posix_time.hpp>

namespace Swift {

class StanzaEvent {

void conclude() {concluded_ = true; onConclusion();}

/** Do not call this directly from outside the class.

* If you connect to this signal, you *must* disconnect from it manually. */

bool getConcluded() {return concluded_;}

boost::posix_time::ptime getTime() {return time_;}

private:

#include <memory>

#include <string>

#include <Swiften/JID/JID.h>

#include <Swift/Controllers/XMPPEvents/StanzaEvent.h>

virtual ~SubscriptionRequestEvent(){}

const JID& getJID() const {return jid_;}

const std::string& getReason() const {return reason_;}

void accept() {

onAccept();

conclude();

#include <string>

namespace Swift {

class URIHandler;

XMPPURIController(URIHandler* uriHandler, UIEventStream* uiEventStream);

~XMPPURIController();

private:

void handleURI(const std::string&);