+ class AdHocCommandWindow {

+ public:

+ virtual ~AdHocCommandWindow() {}

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

+ boost::signal<void ()> onClosing;

+ };

+ class AdHocCommandWindowFactory {

+ public:

+ virtual ~AdHocCommandWindowFactory() {}

+ virtual AdHocCommandWindow* createAdHocCommandWindow(boost::shared_ptr<OutgoingAdHocCommandSession> command) = 0;

+ };

+ class ClientBlockListManager;

+ class BlockListEditorWidget {

+ public:

+ virtual ~BlockListEditorWidget() {}

+ virtual void show() = 0;

+ virtual void hide() = 0;

+ virtual void setCurrentBlockList(const std::vector<JID>& blockedJIDs) = 0;

+ virtual void setBusy(bool isBusy) = 0;

+ virtual void setError(const std::string&) = 0;

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

+ boost::signal<void (const std::vector<JID>& /* blockedJID */)> onSetNewBlockList;

+ };

+ class BlockListEditorWidget;

+ class BlockListEditorWidgetFactory {

+ public:

+ virtual ~BlockListEditorWidgetFactory() {}

+ virtual BlockListEditorWidget* createBlockListEditorWidget() = 0;

+ };

+ class ChatListWindow {

+ public:

+ class Chat {

+ public:

+ Chat() : statusType(StatusShow::None), isMUC(false), unreadCount(0), isPrivateMessage(false) {}

+ Chat(const JID& jid, const std::string& chatName, const std::string& activity, int unreadCount, StatusShow::Type statusType, const boost::filesystem::path& avatarPath, bool isMUC, bool isPrivateMessage = false, const std::string& nick = "", const boost::optional<std::string> password = boost::optional<std::string>())

+ : jid(jid), chatName(chatName), activity(activity), statusType(statusType), isMUC(isMUC), nick(nick), password(password), unreadCount(unreadCount), avatarPath(avatarPath), isPrivateMessage(isPrivateMessage) {}

+ /** Assume that nicks and other transient features aren't important for equality */

+ bool operator==(const Chat& other) const {

+ if (impromptuJIDs.empty()) {

+ return jid.toBare() == other.jid.toBare()

+ && isMUC == other.isMUC;

+ } else { /* compare the chat occupant lists */

+ typedef std::map<std::string, JID> JIDMap;

+ foreach (const JIDMap::value_type& jid, impromptuJIDs) {

+ bool found = false;

+ foreach (const JIDMap::value_type& otherJID, other.impromptuJIDs) {

+ if (jid.second.toBare() == otherJID.second.toBare()) {

+ found = true;

+ break;

+ }

+ }

+ if (!found) {

+ return false;

+ }

+ }

+ return true;

+ }

+ }

+ void setUnreadCount(int unread) {

+ unreadCount = unread;

+ }

+ void setStatusType(StatusShow::Type type) {

+ statusType = type;

+ }

+ void setAvatarPath(const boost::filesystem::path& path) {

+ avatarPath = path;

+ }

+ std::string getImpromptuTitle() const {

+ typedef std::pair<std::string, JID> StringJIDPair;

+ std::string title;

+ foreach(StringJIDPair pair, impromptuJIDs) {

+ if (title.empty()) {

+ title += pair.first;

+ } else {

+ title += ", " + pair.first;

+ }

+ }

+ return title;

+ }

+ JID jid;

+ std::string chatName;

+ std::string activity;

+ StatusShow::Type statusType;

+ bool isMUC;

+ std::string nick;

+ boost::optional<std::string> password;

+ int unreadCount;

+ boost::filesystem::path avatarPath;

+ std::map<std::string, JID> impromptuJIDs;

+ bool isPrivateMessage;

+ };

+ virtual ~ChatListWindow();

+ virtual void setBookmarksEnabled(bool enabled) = 0;

+ virtual void addMUCBookmark(const MUCBookmark& bookmark) = 0;

+ virtual void addWhiteboardSession(const ChatListWindow::Chat& chat) = 0;

+ virtual void removeWhiteboardSession(const JID& jid) = 0;

+ virtual void removeMUCBookmark(const MUCBookmark& bookmark) = 0;

+ virtual void setRecents(const std::list<Chat>& recents) = 0;

+ virtual void setUnreadCount(int unread) = 0;

+ virtual void clearBookmarks() = 0;

+ virtual void setOnline(bool isOnline) = 0;

+ boost::signal<void (const MUCBookmark&)> onMUCBookmarkActivated;

+ boost::signal<void (const Chat&)> onRecentActivated;

+ boost::signal<void (const JID&)> onWhiteboardActivated;

+ boost::signal<void ()> onClearRecentsRequested;

+ };

+ class UIEventStream;

+ class ChatListWindowFactory {

+ public:

+ virtual ~ChatListWindowFactory() {}

+ virtual ChatListWindow* createChatListWindow(UIEventStream* uiEventStream) = 0;

+ };

+ class AvatarManager;

+ class TreeWidget;

+ class Roster;

+ class TabComplete;

+ class RosterItem;

+ class ContactRosterItem;

+ class FileTransferController;

+ class UserSearchWindow;

+

+

+ class ChatWindow {

+ public:

+ class ChatMessagePart {

+ public:

+ virtual ~ChatMessagePart() {}

+ };

+

+ class ChatMessage {

+ public:

+ ChatMessage() {}

+ ChatMessage(const std::string& text) {

+ append(boost::make_shared<ChatTextMessagePart>(text));

+ }

+ void append(const boost::shared_ptr<ChatMessagePart>& part) {

+ parts_.push_back(part);

+ }

+

+ const std::vector<boost::shared_ptr<ChatMessagePart> >& getParts() const {

+ return parts_;

+ }

+

+ void setFullMessageHighlightAction(const HighlightAction& action) {

+ fullMessageHighlightAction_ = action;

+ }

+

+ const HighlightAction& getFullMessageHighlightAction() const {

+ return fullMessageHighlightAction_;

+ }

+

+ bool isMeCommand() const {

+ bool isMeCommand = false;

+ if (!parts_.empty()) {

+ boost::shared_ptr<ChatTextMessagePart> textPart = boost::dynamic_pointer_cast<ChatTextMessagePart>(parts_[0]);

+ if (textPart) {

+ if (boost::starts_with(textPart->text, "/me ")) {

+ isMeCommand = true;

+ }

+ }

+ }

+ return isMeCommand;

+ }

+

+ private:

+ std::vector<boost::shared_ptr<ChatMessagePart> > parts_;

+ HighlightAction fullMessageHighlightAction_;

+ };

+

+ class ChatTextMessagePart : public ChatMessagePart {

+ public:

+ ChatTextMessagePart(const std::string& text) : text(text) {}

+ std::string text;

+ };

+

+ class ChatURIMessagePart : public ChatMessagePart {

+ public:

+ ChatURIMessagePart(const std::string& target) : target(target) {}

+ std::string target;

+ };

+

+ class ChatEmoticonMessagePart : public ChatMessagePart {

+ public:

+ std::string imagePath;

+ std::string alternativeText;

+ };

+

+ class ChatHighlightingMessagePart : public ChatMessagePart {

+ public:

+ HighlightAction action;

+ std::string text;

+ };

+

+

+ enum AckState {Pending, Received, Failed};

+ enum ReceiptState {ReceiptRequested, ReceiptReceived, ReceiptFailed};

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

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

+ enum FileTransferState {

+ Initialisation, ///< Collecting information required for sending the request out.

+ WaitingForAccept, ///< The file transfer request was send out.

+ Negotiating, ///< The other party accepted the file transfer request and a suitable transfer method is negotiated.

+ Transferring, ///< The negotiation was successful and the file is currently transferred.

+ Canceled, ///< Someone actively canceled the transfer.

+ Finished, ///< The file was transferred successfully.

+ FTFailed ///< The negotiation, the transfer itself or the verification failed.

+ };

+ enum WhiteboardSessionState {WhiteboardAccepted, WhiteboardTerminated, WhiteboardRejected};

+ enum BlockingState {BlockingUnsupported, IsBlocked, IsUnblocked};

+ enum Direction { UnknownDirection, DefaultDirection };

+ enum MUCType { StandardMUC, ImpromptuMUC };

+ enum TimestampBehaviour { KeepTimestamp, UpdateTimestamp };

+ enum RoomBookmarkState { RoomNotBookmarked, RoomBookmarked, RoomAutoJoined };

+

+ 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) = 0;

+ /** Adds action to window.

+ * @return id of added message (for acks);

+ */

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

+

+ /** Adds system message to window

+ * @return id of added message (for replacement)

+ */

+ virtual std::string addSystemMessage(const ChatMessage& message, Direction direction) = 0;

+ virtual void addPresenceMessage(const ChatMessage& message, Direction direction) = 0;

+

+ virtual void addErrorMessage(const ChatMessage& message) = 0;

+ virtual void replaceMessage(const ChatMessage& message, const std::string& id, const boost::posix_time::ptime& time) = 0;

+ virtual void replaceSystemMessage(const ChatMessage& message, const std::string& id, const TimestampBehaviour timestampBehaviour) = 0;

+ virtual void replaceWithAction(const ChatMessage& message, const std::string& id, const boost::posix_time::ptime& time) = 0;

+

+ // File transfer related stuff

+ virtual std::string addFileTransfer(const std::string& senderName, bool senderIsSelf, const std::string& filename, const boost::uintmax_t sizeInBytes, const std::string& description) = 0;

+ virtual void setFileTransferProgress(std::string, const int percentageDone) = 0;

+ virtual void setFileTransferStatus(std::string, const FileTransferState state, const std::string& msg = "") = 0;

+ virtual void addMUCInvitation(const std::string& senderName, const JID& jid, const std::string& reason, const std::string& password, bool direct = true, bool isImpromptu = false, bool isContinuation = false) = 0;

+

+ virtual std::string addWhiteboardRequest(bool senderIsSelf) = 0;

+ virtual void setWhiteboardSessionStatus(std::string id, const ChatWindow::WhiteboardSessionState state) = 0;

+

+ // message receipts

+ virtual void setMessageReceiptState(const std::string& id, ChatWindow::ReceiptState state) = 0;

+

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

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

+ virtual void show() = 0;

+ virtual bool isVisible() const = 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 setFileTransferEnabled(Tristate enabled) = 0;

+ virtual void setUnreadMessageCount(int count) = 0;

+ virtual void convertToMUC(MUCType mucType) = 0;

+// virtual TreeWidget *getTreeWidget() = 0;

+ virtual void setSecurityLabelsError() = 0;

+ virtual SecurityLabelsCatalog::Item getSelectedSecurityLabel() = 0;

+ virtual void setOnline(bool online) = 0;

+ virtual void setRosterModel(Roster* model) = 0;

+ virtual void setTabComplete(TabComplete* completer) = 0;

+ virtual void replaceLastMessage(const ChatMessage& message, const TimestampBehaviour timestampBehaviour) = 0;

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

+ virtual void flash() = 0;

+ virtual void setSubject(const std::string& subject) = 0;

+ virtual void setAffiliations(MUCOccupant::Affiliation, const std::vector<JID>&) = 0;

+ virtual void setAvailableRoomActions(const std::vector<RoomAction> &actions) = 0;

+ virtual void setBlockingState(BlockingState state) = 0;

+ virtual void setCanInitiateImpromptuChats(bool supportsImpromptu) = 0;

+ virtual void showBookmarkWindow(const MUCBookmark& bookmark) = 0;

+ virtual void setBookmarkState(RoomBookmarkState bookmarkState) = 0;

+

+ /**

+ * A handle that uniquely identities an alert message.

+ */

+ typedef int AlertID;

+ /**

+ * 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).

+ * @return A handle to the alert message.

+ */

+ virtual AlertID addAlert(const std::string& alertText) = 0;

+ /**

+ * Removes an alert.

+ * @param id An alert ID previously returned from setAlert

+ */

+ virtual void removeAlert(const AlertID id) = 0;

+

+ /**

+ * Actions that can be performed on the selected occupant.

+ */

+ virtual void setAvailableOccupantActions(const std::vector<OccupantAction>& actions) = 0;

+

+ /**

+ * A room configuration has been requested, show the form.

+ * If the form is cancelled, must emit onConfigurationFormCancelled().

+ */

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

+

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

+ boost::signal<void (const std::string&)> onChangeSubjectRequest;

+ boost::signal<void ()> onBookmarkRequest;

+ boost::signal<void (Form::ref)> onConfigureRequest;

+ boost::signal<void ()> onDestroyRequest;

+ boost::signal<void (const std::vector<JID>&)> onInviteToChat;

+ boost::signal<void ()> onConfigurationFormCancelled;

+ boost::signal<void ()> onGetAffiliationsRequest;

+ boost::signal<void (MUCOccupant::Affiliation, const JID&)> onSetAffiliationRequest;

+ boost::signal<void (const std::vector<std::pair<MUCOccupant::Affiliation, JID> >& changes)> onChangeAffiliationsRequest;

+ boost::signal<void ()> onLogCleared;

+

+ // 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;

+

+ //Whiteboard related

+ boost::signal<void ()> onWhiteboardSessionAccept;

+ boost::signal<void ()> onWhiteboardSessionCancel;

+ boost::signal<void ()> onWhiteboardWindowShow;

+

+ // Blocking Command related

+ boost::signal<void ()> onBlockUserRequest;

+ boost::signal<void ()> onUnblockUserRequest;

+ };

+ class ChatWindow;

+ class UIEventStream;

+ class ChatWindowFactory {

+ public:

+ virtual ~ChatWindowFactory() {}

+ /**

+ * Transfers ownership of result.

+ */

+ virtual ChatWindow* createChatWindow(const JID &contact, UIEventStream* eventStream) = 0;

+ };

+ class JID;

+ class VCardManager;

+ class ContactEditWindow {

+ public:

+ virtual ~ContactEditWindow() {}

+ virtual void setEnabled(bool b) = 0;

+ virtual void setNameSuggestions(const std::vector<std::string>& suggestions) = 0;

+ virtual void setContact(const JID& jid, const std::string& name, const std::vector<std::string>& groups, const std::set<std::string>& allGroups) = 0;

+ virtual void show() = 0;

+ virtual void hide() = 0;

+ boost::signal<void ()> onRemoveContactRequest;

+ boost::signal<void (const std::string& /* name */, const std::set<std::string>& /* groups */)> onChangeContactRequest;

+ };

+ class ContactEditWindowFactory {

+ public:

+ virtual ~ContactEditWindowFactory() {}

+ virtual ContactEditWindow* createContactEditWindow() = 0;

+ };

+ class EventWindow {

+ public:

+ EventWindow(bool candelete = true) : canDelete_(candelete) {}

+ bool canDelete() const {

+ return canDelete_;

+ }

+ virtual ~EventWindow() {}

+ virtual void addEvent(boost::shared_ptr<StanzaEvent> event, bool active) = 0;

+ virtual void removeEvent(boost::shared_ptr<StanzaEvent> event) = 0;

+ private:

+ bool canDelete_;

+ };

+ class EventWindow;

+ class EventWindowFactory {

+ public:

+ virtual ~EventWindowFactory() {}

+ /**

+ * Transfers ownership of result.

+ */

+ virtual EventWindow* createEventWindow() = 0;

+ };

+ virtual ~FileTransferListWidget() {}

+ virtual void show() = 0;

+ virtual void activate() = 0;

+ virtual void setFileTransferOverview(FileTransferOverview*) = 0;

+ virtual ~FileTransferListWidgetFactory() {}

+ virtual FileTransferListWidget* createFileTransferListWidget() = 0;

+ class HighlightManager;

+ class HighlightEditorWidget {

+ public:

+ virtual ~HighlightEditorWidget() {}

+ virtual void show() = 0;

+ virtual void setHighlightManager(HighlightManager* highlightManager) = 0;

+ };

+ class HighlightEditorWidget;

+ class HighlightEditorWidgetFactory {

+ public:

+ virtual ~HighlightEditorWidgetFactory() {}

+ virtual HighlightEditorWidget* createHighlightEditorWidget() = 0;

+ };

+ HighlightEditorWindow();

+ virtual ~HighlightEditorWindow();

+ virtual void show() = 0;

+ virtual void setHighlightManager(HighlightManager *highlightManager) = 0;

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

+ boost::signal<void (const std::string&)> onContactSuggestionsRequested;

+ class HighlightEditorWindow;

+ class HighlightEditorWindowFactory {

+ public :

+ virtual ~HighlightEditorWindowFactory() {}

+ virtual HighlightEditorWindow* createHighlightEditorWindow() = 0;

+ };

+ class HistoryWindow {

+ public:

+ virtual ~HistoryWindow() {}

+ virtual void activate() = 0;

+ virtual void setRosterModel(Roster*) = 0;

+ virtual void addMessage(const std::string &message, const std::string &senderName, bool senderIsSelf, const std::string& avatarPath, const boost::posix_time::ptime& time, bool addAtTheTop) = 0;

+ virtual void resetConversationView() = 0;

+ virtual void resetConversationViewTopInsertPoint() = 0; // this is a temporary fix used in adding messages at the top

+ virtual void setDate(const boost::gregorian::date& date) = 0;

+ virtual std::string getSearchBoxText() = 0;

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

+ boost::signal<void (RosterItem*)> onSelectedContactChanged;

+ boost::signal<void (const std::string&)> onReturnPressed;

+ boost::signal<void (const boost::gregorian::date&)> onScrollReachedTop;

+ boost::signal<void (const boost::gregorian::date&)> onScrollReachedBottom;

+ boost::signal<void ()> onPreviousButtonClicked;

+ boost::signal<void ()> onNextButtonClicked;

+ boost::signal<void (const boost::gregorian::date&)> onCalendarClicked;

+ };

+ class UIEventStream;

+ class HistoryWindowFactory {

+ public:

+ virtual ~HistoryWindowFactory() {}

+ virtual HistoryWindow* createHistoryWindow(UIEventStream* eventStream) = 0;

+ };

+ class JoinMUCWindow {

+ public:

+ virtual ~JoinMUCWindow() {}

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

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

+ virtual void show() = 0;

+ boost::signal<void ()> onSearchMUC;

+ };

+ class UIEventStream;

+ class JoinMUCWindowFactory {

+ public:

+ virtual ~JoinMUCWindowFactory() {}

+ virtual JoinMUCWindow* createJoinMUCWindow(UIEventStream* uiEventStream) = 0;

+ };

+ class MainWindow;

+ class LoginWindow {

+ public:

+ virtual ~LoginWindow() {}

+ virtual void selectUser(const std::string&) = 0;

+ virtual void morphInto(MainWindow *mainWindow) = 0;

+ virtual void loggedOut() = 0;

+ virtual void setShowNotificationToggle(bool) = 0;

+ virtual void setMessage(const std::string&) = 0;

+ virtual void setIsLoggingIn(bool loggingIn) = 0;

+ 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*/

+ boost::signal<void (const std::string&, const std::string&, const std::string& /*CertificatePath*/, CertificateWithKey::ref /* clientCertificate */, const ClientOptions& /*options*/, bool /* remember password*/, bool /* login automatically */)> onLoginRequest;

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

+ boost::signal<void ()> onCancelLoginRequest;

+ boost::signal<void ()> onQuitRequest;

+ boost::signal<void (const std::string&)> onPurgeSavedLoginRequest;

+ };

+ class LoginWindow;

+

+ class UIEventStream;

+

+ class LoginWindowFactory {

+ public:

+ virtual ~LoginWindowFactory() {}

+

+ /**

+ * Transfers ownership of result.

+ */

+ virtual LoginWindow* createLoginWindow(UIEventStream* uiEventStream) = 0;

+

+ };

+ class MUCSearchWindow {

+ public:

+ virtual ~MUCSearchWindow() {}

+ virtual void clearList() = 0;

+ virtual void addService(const MUCService& service) = 0;

+ virtual void addSavedServices(const std::list<JID>& services) = 0;

+ virtual void setSearchInProgress(bool searching) = 0;

+ virtual void show() = 0;

+ boost::signal<void (const JID&)> onSearchService;

+ boost::signal<void (const boost::optional<JID>&)> onFinished;

+ };

+ class UIEventStream;

+ class MUCSearchWindowFactory {

+ public:

+ virtual ~MUCSearchWindowFactory() {}

+ virtual MUCSearchWindow* createMUCSearchWindow() = 0;

+ };

+ class Roster;

+

+ class MainWindow {

+ public:

+ MainWindow(bool candelete = true) : canDelete_(candelete) {}

+ virtual ~MainWindow() {}

+

+ bool canDelete() const {

+ return canDelete_;

+ }

+

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

+ virtual void setMyJID(const JID& jid) = 0;

+ virtual void setMyAvatarPath(const std::string& path) = 0;

+ virtual void setMyStatusText(const std::string& status) = 0;

+ virtual void setMyStatusType(StatusShow::Type type) = 0;

+ virtual void setMyContactRosterItem(boost::shared_ptr<ContactRosterItem> contact) = 0;

+ /** Must be able to cope with NULL to clear the roster */

+ virtual void setRosterModel(Roster* roster) = 0;

+ virtual void setConnecting() = 0;

+ virtual void setBlockingCommandAvailable(bool isAvailable) = 0;

+ virtual void setAvailableAdHocCommands(const std::vector<DiscoItems::Item>& commands) = 0;

+ virtual void setStreamEncryptionStatus(bool tlsInPlaceAndValid) = 0;

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

+

+ boost::signal<void (StatusShow::Type, const std::string&)> onChangeStatusRequest;

+ boost::signal<void ()> onSignOutRequest;

+ boost::signal<void ()> onShowCertificateRequest;

+

+ private:

+ bool canDelete_;

+ };

+ class MainWindow;

+ class MainWindowFactory {

+ public:

+ virtual ~MainWindowFactory() {}

+ /**

+ * Transfers ownership of result.

+ */

+ virtual MainWindow* createMainWindow(UIEventStream* eventStream) = 0;

+ };

+ class JID;

+ class ProfileWindow {

+ public:

+ virtual ~ProfileWindow() {}

+ virtual void setJID(const JID& jid) = 0;

+ virtual void setVCard(VCard::ref vcard) = 0;

+ virtual void setEnabled(bool b) = 0;

+ virtual void setProcessing(bool b) = 0;

+ virtual void setError(const std::string&) = 0;

+ virtual void setEditable(bool b) = 0;

+ virtual void show() = 0;

+ virtual void hide() = 0;

+ boost::signal<void (VCard::ref)> onVCardChangeRequest;

+ boost::signal<void (const JID&)> onWindowAboutToBeClosed;

+ };

+ class ProfileWindowFactory {

+ public:

+ virtual ~ProfileWindowFactory() {}

+ virtual ProfileWindow* createProfileWindow() = 0;

+ };

+ class UIFactory :

+ public ChatListWindowFactory,

+ public ChatWindowFactory,

+ public HistoryWindowFactory,

+ public EventWindowFactory,

+ public LoginWindowFactory,

+ public MainWindowFactory,

+ public MUCSearchWindowFactory,

+ public XMLConsoleWidgetFactory,

+ public UserSearchWindowFactory,

+ public JoinMUCWindowFactory,

+ public ProfileWindowFactory,

+ public ContactEditWindowFactory,

+ public AdHocCommandWindowFactory,

+ public FileTransferListWidgetFactory,

+ public WhiteboardWindowFactory,

+ public HighlightEditorWindowFactory,

+ public BlockListEditorWidgetFactory {

+ public:

+ virtual ~UIFactory() {}

+ };

+ class UserSearchWindow {

+ public:

+ enum Type {AddContact, ChatToContact, InviteToChat};

+ virtual ~UserSearchWindow() {}

+

+ virtual void clear() = 0;

+ virtual void setResults(const std::vector<UserSearchResult>& results) = 0;

+ virtual void setResultsForm(const Form::ref results) = 0;

+ virtual void addSavedServices(const std::vector<JID>& services) = 0;

+ virtual void setSelectedService(const JID& service) = 0;

+ virtual void setServerSupportsSearch(bool support) = 0;

+ virtual void setSearchError(bool support) = 0;

+ virtual void setSearchFields(boost::shared_ptr<SearchPayload> fields) = 0;

+ virtual void setNameSuggestions(const std::vector<std::string>& suggestions) = 0;

+ virtual void prepopulateJIDAndName(const JID& jid, const std::string& name) = 0;

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

+ virtual void setJIDs(const std::vector<JID>&) = 0;

+ virtual void setRoomJID(const JID& roomJID) = 0;

+ virtual std::string getReason() const = 0;

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

+ virtual void setCanStartImpromptuChats(bool supportsImpromptu) = 0;

+ virtual void updateContacts(const std::vector<Contact::ref>& contacts) = 0;

+ virtual void addContacts(const std::vector<Contact::ref>& contacts) = 0;

+ virtual void setCanSupplyDescription(bool allowed) = 0;

+ virtual void setWarning(const boost::optional<std::string>& message) = 0;

+

+ virtual void show() = 0;

+

+ boost::signal<void (const JID&)> onFormRequested;

+ boost::signal<void (boost::shared_ptr<SearchPayload>, const JID&)> onSearchRequested;

+ boost::signal<void (const JID&)> onNameSuggestionRequested;

+ boost::signal<void (const std::string&)> onContactSuggestionsRequested;

+ boost::signal<void (const std::vector<JID>&)> onJIDUpdateRequested;

+ boost::signal<void (const std::vector<JID>&)> onJIDAddRequested;

+ boost::signal<void (const JID&)> onJIDEditFieldChanged;

+ };

+ class UIEventStream;

+ class UserSearchWindowFactory {

+ public:

+ virtual ~UserSearchWindowFactory() {}

+ virtual UserSearchWindow* createUserSearchWindow(UserSearchWindow::Type type, UIEventStream* eventStream, const std::set<std::string>& groups) = 0;

+ };

+ class WhiteboardSession;

+ class WhiteboardElement;

+ class WhiteboardWindow {

+ public:

+ virtual ~WhiteboardWindow() {}

+ virtual void show() = 0;

+ virtual void setSession(boost::shared_ptr<WhiteboardSession> session) = 0;

+ virtual void activateWindow() = 0;

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

+ };

+ class WhiteboardSession;

+ class WhiteboardWindow;

+ class WhiteboardWindowFactory {

+ public :

+ virtual ~WhiteboardWindowFactory() {}

+ virtual WhiteboardWindow* createWhiteboardWindow(boost::shared_ptr<WhiteboardSession> whiteboardSession) = 0;

+ };

+ class XMLConsoleWidget {

+ public:

+ virtual ~XMLConsoleWidget();

+ virtual void handleDataRead(const SafeByteArray& data) = 0;

+ virtual void handleDataWritten(const SafeByteArray& data) = 0;

+ virtual void show() = 0;

+ virtual void activate() = 0;

+ };

+ class UIEventStream;

+ class XMLConsoleWidgetFactory {

+ public:

+ virtual ~XMLConsoleWidgetFactory() {}

+ virtual XMLConsoleWidget* createXMLConsoleWidget() = 0;

+ };