+ class AcceptWhiteboardSessionUIEvent : public UIEvent {

+ typedef boost::shared_ptr<AcceptWhiteboardSessionUIEvent> ref;

+ public:

+ AcceptWhiteboardSessionUIEvent(const JID& jid) : jid_(jid) {}

+ const JID& getContact() const {return jid_;}

+ private:

+ JID jid_;

+ };

+ class AddContactUIEvent : public UIEvent {

+ public:

+ AddContactUIEvent(const JID& jid, const std::string& name, const std::set<std::string>& groups) : jid_(jid), name_(name), groups_(groups) {}

+

+ const std::string& getName() const {

+ return name_;

+ }

+

+ const JID& getJID() const {

+ return jid_;

+ }

+

+ const std::set<std::string>& getGroups() const {

+ return groups_;

+ }

+

+ private:

+ JID jid_;

+ std::string name_;

+ std::set<std::string> groups_;

+ };

+ class AddMUCBookmarkUIEvent : public UIEvent {

+ public:

+ AddMUCBookmarkUIEvent(const MUCBookmark& bookmark) : bookmark(bookmark) {}

+ const MUCBookmark& getBookmark() { return bookmark; }

+ private:

+ MUCBookmark bookmark;

+ };

+ class CancelWhiteboardSessionUIEvent : public UIEvent {

+ typedef boost::shared_ptr<CancelWhiteboardSessionUIEvent> ref;

+ public:

+ CancelWhiteboardSessionUIEvent(const JID& jid) : jid_(jid) {}

+ const JID& getContact() const {return jid_;}

+ private:

+ JID jid_;

+ };

+ public:

+ CreateImpromptuMUCUIEvent(const std::vector<JID>& jids, const JID& roomJID = JID(), const std::string reason = "") : jids_(jids), roomJID_(roomJID), reason_(reason) { }

+ std::vector<JID> getJIDs() const { return jids_; }

+ JID getRoomJID() const { return roomJID_; }

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

+ private:

+ std::vector<JID> jids_;

+ JID roomJID_;

+ std::string reason_;

+ class EditMUCBookmarkUIEvent : public UIEvent {

+ public:

+ EditMUCBookmarkUIEvent(const MUCBookmark& oldBookmark, const MUCBookmark& newBookmark) : oldBookmark(oldBookmark) , newBookmark(newBookmark) {}

+ const MUCBookmark& getOldBookmark() {return oldBookmark;}

+ const MUCBookmark& getNewBookmark() {return newBookmark;}

+ private:

+ MUCBookmark oldBookmark;

+ MUCBookmark newBookmark;

+ };

+ class InviteToMUCUIEvent : public UIEvent {

+ public:

+ typedef boost::shared_ptr<InviteToMUCUIEvent> ref;

+

+ InviteToMUCUIEvent(const JID& room, const std::vector<JID>& JIDsToInvite, const std::string& reason) : room_(room), invite_(JIDsToInvite), reason_(reason) {

+ }

+

+ const JID& getRoom() const {

+ return room_;

+ }

+

+ const std::vector<JID> getInvites() const {

+ return invite_;

+ }

+

+ const std::string getReason() const {

+ return reason_;

+ }

+

+ private:

+ JID room_;

+ std::vector<JID> invite_;

+ std::string reason_;

+ };

+ class JoinMUCUIEvent : public UIEvent {

+ public:

+ typedef boost::shared_ptr<JoinMUCUIEvent> ref;

+ JoinMUCUIEvent(const JID& jid, const boost::optional<std::string>& password = boost::optional<std::string>(), const boost::optional<std::string>& nick = boost::optional<std::string>(), bool joinAutomaticallyInFuture = false, bool createAsReservedRoomIfNew = false, bool isImpromptu = false, bool isContinuation = false) : jid_(jid), nick_(nick), joinAutomatically_(joinAutomaticallyInFuture), createAsReservedRoomIfNew_(createAsReservedRoomIfNew), password_(password), isImpromptuMUC_(isImpromptu), isContinuation_(isContinuation) {}

+ const boost::optional<std::string>& getNick() const {return nick_;}

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

+ bool getShouldJoinAutomatically() const {return joinAutomatically_;}

+ bool getCreateAsReservedRoomIfNew() const {return createAsReservedRoomIfNew_;}

+ const boost::optional<std::string>& getPassword() const {return password_;}

+ bool isImpromptu() const {return isImpromptuMUC_;}

+ bool isContinuation() const {return isContinuation_;}

+ private:

+ JID jid_;

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

+ bool joinAutomatically_;

+ bool createAsReservedRoomIfNew_;

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

+ bool isImpromptuMUC_;

+ bool isContinuation_;

+ };

+ class RemoveMUCBookmarkUIEvent : public UIEvent {

+ public:

+ RemoveMUCBookmarkUIEvent(const MUCBookmark& bookmark) : bookmark(bookmark) {}

+ const MUCBookmark& getBookmark() { return bookmark; }

+ private:

+ MUCBookmark bookmark;

+ };

+ public:

+ RemoveRosterItemUIEvent(const JID& jid) : jid_(jid) {}

+ virtual ~RemoveRosterItemUIEvent() {}

+ JID getJID() {return jid_;}

+ private:

+ JID jid_;

+ class RenameGroupUIEvent : public UIEvent {

+ public:

+ RenameGroupUIEvent(const std::string& group, const std::string& newName) : group(group), newName(newName) {

+ }

+ const std::string& getGroup() const {

+ return group;

+ }

+ const std::string& getNewName() const {

+ return newName;

+ }

+ private:

+ std::string group;

+ std::string newName;

+ };

+ class RenameRosterItemUIEvent : public UIEvent {

+ public:

+ RenameRosterItemUIEvent(const JID& jid, const std::string& newName) : jid_(jid), newName_(newName) {}

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

+ const std::string& getNewName() const {return newName_;}

+ private:

+ JID jid_;

+ std::string newName_;

+ };

+ class RequestAdHocUIEvent : public UIEvent {

+ public:

+ RequestAdHocUIEvent(const DiscoItems::Item& command) : command_(command) {}

+ const DiscoItems::Item& getCommand() const {return command_;}

+ private:

+ DiscoItems::Item command_;

+ };

+ class RequestAdHocWithJIDUIEvent : public UIEvent {

+ public:

+ RequestAdHocWithJIDUIEvent(const JID& jid, const std::string& node) : jid_(jid), node_(node) {}

+ JID getJID() const { return jid_; }

+ std::string getNode() const { return node_; }

+ private:

+ JID jid_;

+ std::string node_;

+ };

+ class RequestAddUserDialogUIEvent : public UIEvent {

+ public:

+ RequestAddUserDialogUIEvent(const JID& predefinedJID, const std::string& predefinedName) : preJID_(predefinedJID), preName_(predefinedName) {}

+ RequestAddUserDialogUIEvent() : preJID_(), preName_() {}

+ const JID& getPredefinedJID() const { return preJID_; }

+ const std::string& getPredefinedName() const { return preName_; }

+ private:

+ JID preJID_;

+ std::string preName_;

+ };

+ public:

+ enum BlockState {

+ Blocked,

+ Unblocked

+ };

+

+ public:

+ RequestChangeBlockStateUIEvent(BlockState newState, const JID& contact) : state_(newState), contact_(contact) {}

+

+ BlockState getBlockState() const {

+ return state_;

+ }

+

+ JID getContact() const {

+ return contact_;

+ }

+ private:

+ BlockState state_;

+ JID contact_;

+ class RequestChatUIEvent : public UIEvent {

+ public:

+ RequestChatUIEvent(const JID& contact) : contact_(contact) {}

+ JID getContact() {return contact_;}

+ private:

+ JID contact_;

+ };

+ class RequestChatWithUserDialogUIEvent : public UIEvent {

+ };

+ class RequestContactEditorUIEvent : public UIEvent {

+ public:

+ typedef boost::shared_ptr<RequestContactEditorUIEvent> ref;

+ RequestContactEditorUIEvent(const JID& jid) : jid(jid) {

+ }

+ const JID& getJID() const {

+ return jid;

+ }

+ private:

+ JID jid;

+ };

+ class RequestHighlightEditorUIEvent : public UIEvent {

+ };

+ class RequestHistoryUIEvent : public UIEvent {

+ };

+ class RequestInviteToMUCUIEvent : public UIEvent {

+ public:

+ typedef boost::shared_ptr<RequestInviteToMUCUIEvent> ref;

+

+ enum ImpromptuMode {

+ Impromptu,

+ NotImpromptu

+ };

+

+ RequestInviteToMUCUIEvent(const JID& room, const std::vector<JID>& JIDsToInvite, ImpromptuMode impromptu) : room_(room), invite_(JIDsToInvite) {

+ isImpromptu_ = impromptu == Impromptu;

+ }

+

+ const JID& getRoom() const {

+ return room_;

+ }

+

+ const std::vector<JID> getInvites() const {

+ return invite_;

+ }

+

+ bool isImpromptu() const {

+ return isImpromptu_;

+ }

+

+ private:

+ JID room_;

+ std::vector<JID> invite_;

+ bool isImpromptu_;

+ };

+ class RequestJoinMUCUIEvent : public UIEvent {

+ public:

+ typedef boost::shared_ptr<RequestJoinMUCUIEvent> ref;

+ RequestJoinMUCUIEvent(const JID& room = JID()) : room(room) {

+ }

+ const JID& getRoom() const {

+ return room;

+ }

+ private:

+ JID room;

+ };

+ class RequestProfileEditorUIEvent : public UIEvent {

+ public:

+ RequestProfileEditorUIEvent() {}

+ };

+ class RequestWhiteboardUIEvent : public UIEvent {

+ public:

+ RequestWhiteboardUIEvent(const JID& contact) : contact_(contact) {}

+ const JID& getContact() const {return contact_;}

+ private:

+ JID contact_;

+ };

+ class RequestXMLConsoleUIEvent : public UIEvent {

+ };

+ class SendFileUIEvent : public UIEvent {

+ public:

+ typedef boost::shared_ptr<SendFileUIEvent> ref;

+

+ SendFileUIEvent(const JID& jid, const std::string& filename) : jid(jid), filename(filename) {

+ }

+

+ const JID& getJID() const {

+ return jid;

+ }

+

+ const std::string& getFilename() const {

+ return filename;

+ }

+

+ private:

+ JID jid;

+ std::string filename;

+ };

+ public:

+ typedef boost::shared_ptr<ShowProfileForRosterItemUIEvent> ref;

+ public:

+ ShowProfileForRosterItemUIEvent(const JID& jid) : jid_(jid) {}

+ virtual ~ShowProfileForRosterItemUIEvent() {}

+ JID getJID() const {return jid_;}

+ private:

+ JID jid_;

+ class ShowWhiteboardUIEvent : public UIEvent {

+ public:

+ ShowWhiteboardUIEvent(const JID& contact) : contact_(contact) {}

+ const JID& getContact() const {return contact_;}

+ private:

+ JID contact_;

+ };

+ class UIEvent {

+ public:

+ typedef boost::shared_ptr<UIEvent> ref;

+ virtual ~UIEvent();

+ };

+ class UIEventStream {

+ public:

+ boost::signal<void (boost::shared_ptr<UIEvent>)> onUIEvent;

+ void send(boost::shared_ptr<UIEvent> event) {

+ onUIEvent(event);

+ }

+ };