2 files changed, 5 insertions, 3 deletions
diff --git a/Swift/Controllers/UIInterfaces/ChatListWindow.h b/Swift/Controllers/UIInterfaces/ChatListWindow.h
index 38d8c3e..f7eb151 100644
--- a/Swift/Controllers/UIInterfaces/ChatListWindow.h
+++ b/Swift/Controllers/UIInterfaces/ChatListWindow.h
@@ -1,97 +1,98 @@
 /*
  * Copyright (c) 2010-2014 Kevin Smith
  * Licensed under the GNU General Public License v3.
  * See Documentation/Licenses/GPLv3.txt for more information.
  */
 
 #pragma once
 
 #include <list>
 #include <set>
 #include <map>
 #include <boost/shared_ptr.hpp>
 #include <Swiften/MUC/MUCBookmark.h>
 #include <Swiften/Elements/StatusShow.h>
 #include <boost/filesystem/path.hpp>
 #include <Swiften/Base/foreach.h>
 #include <Swiften/Base/boost_bsignals.h>
 
 namespace Swift {
 	class ChatListWindow {
 		public:
 			class Chat {
 				public:
-					Chat() : statusType(StatusShow::None), isMUC(false), unreadCount(0) {}
-					Chat(const JID& jid, const std::string& chatName, const std::string& activity, int unreadCount, StatusShow::Type statusType, const boost::filesystem::path& avatarPath, bool isMUC, 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) {}
+					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;
 
 			boost::signal<void (const MUCBookmark&)> onMUCBookmarkActivated;
 			boost::signal<void (const Chat&)> onRecentActivated;
 			boost::signal<void (const JID&)> onWhiteboardActivated;
 			boost::signal<void ()> onClearRecentsRequested;
 	};
 }
diff --git a/Swift/Controllers/UIInterfaces/ChatWindow.h b/Swift/Controllers/UIInterfaces/ChatWindow.h
index bf4744b..81d26c8 100644
--- a/Swift/Controllers/UIInterfaces/ChatWindow.h
+++ b/Swift/Controllers/UIInterfaces/ChatWindow.h
@@ -1,213 +1,214 @@
 /*
  * Copyright (c) 2010-2014 Kevin Smith
  * Licensed under the GNU General Public License v3.
  * See Documentation/Licenses/GPLv3.txt for more information.
  */
 
 #pragma once
 
 #include <vector>
 #include <string>
 
 #include <boost/optional.hpp>
 #include <boost/shared_ptr.hpp>
 #include <boost/make_shared.hpp>
 #include <boost/date_time/posix_time/posix_time.hpp>
 
 #include <Swiften/Base/boost_bsignals.h>
 #include <Swiften/Elements/SecurityLabelsCatalog.h>
 #include <Swiften/Elements/ChatState.h>
 #include <Swiften/Elements/Form.h>
 #include <Swiften/Elements/MUCOccupant.h>
 #include <Swiften/MUC/MUCBookmark.h>
 #include <Swift/Controllers/HighlightManager.h>
 
 
 namespace Swift {
 	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_;
 					}
 				private:
 					std::vector<boost::shared_ptr<ChatMessagePart> > parts_;
 			};
 
 			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:
 					std::string foregroundColor;
 					std::string backgroundColor;
 					std::string text;
 			};
 
 
 			enum AckState {Pending, Received, Failed};
 			enum ReceiptState {ReceiptRequested, ReceiptReceived, ReceiptFailed};
 			enum Tristate {Yes, No, Maybe};
 			enum OccupantAction {Kick, Ban, MakeModerator, MakeParticipant, MakeVisitor, AddContact, ShowProfile};
 			enum RoomAction {ChangeSubject, Configure, Affiliations, Destroy, Invite};
 			enum FileTransferState {WaitingForAccept, Negotiating, Transferring, Canceled, Finished, FTFailed};
 			enum WhiteboardSessionState {WhiteboardAccepted, WhiteboardTerminated, WhiteboardRejected};
 			enum BlockingState {BlockingUnsupported, IsBlocked, IsUnblocked};
 			enum Direction { UnknownDirection, DefaultDirection };
 			enum MUCType { StandardMUC, ImpromptuMUC };
 			enum TimestampBehaviour { KeepTimestamp, UpdateTimestamp };
 
 			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, const HighlightAction& highlight) = 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, const HighlightAction& highlight) = 0;
 
 			virtual void 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, const HighlightAction& highlight) = 0;
 			virtual void replaceWithAction(const ChatMessage& message, const std::string& id, const boost::posix_time::ptime& time, const HighlightAction& highlight) = 0;
 			
 			// File transfer related stuff
 			virtual std::string addFileTransfer(const std::string& senderName, bool senderIsSelf, const std::string& filename, const boost::uintmax_t sizeInBytes) = 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 setInputEnabled(bool enabled) = 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;
 			/**
 			 * 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).
 			 */
 			virtual void setAlert(const std::string& alertText, const std::string& buttonText = "") = 0;
 			/**
 			 * Removes an alert.
 			 */
 			virtual void cancelAlert() = 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;
 	};
 }