public ChatRoomInvitationDialog(Network network, Node inviteFrom, ChatRoom room, ChatInviteInfo invitation)
: base("ChatRoomInvitationDialog")
{
this.room = room;
this.invitation = invitation;
descLabel.Markup = String.Format(descLabel.Text, GLib.Markup.EscapeText(inviteFrom.ToString()), GLib.Markup.EscapeText(room.Name));
messageContainer.Visible = !String.IsNullOrEmpty(invitation.Message);
messageLabel.Text = GLib.Markup.EscapeText(invitation.Message);
passwordInfoBox.Visible = room.HasPassword;
passwordEntry.Text = invitation.Password;
showPasswordCheck.Visible = !String.IsNullOrEmpty(invitation.Password);
Validate();
}
public ChatRoomSubpage(ChatRoom room)
: base()
{
this.thisRoom = room;
this.network = room.Network;
userListStore = new ListStore (typeof (Node));
userList.Model = userListStore;
var iconCell = new CellRendererPixbuf();
var textCell = new CellRendererText();
var column = new TreeViewColumn();
column.PackStart(iconCell, false);
column.SetCellDataFunc(iconCell, new TreeCellDataFunc(UserListIconFunc));
column.PackStart(textCell, true);
column.SetCellDataFunc(textCell, new TreeCellDataFunc (UserListTextFunc));
userList.AppendColumn(column);
userList.HeadersVisible = false;
userList.RowActivated += on_userList_RowActivated;
userList.ButtonReleaseEvent += on_userList_button_release_event;
foreach (Node n in room.Users.Values) {
userListStore.AppendValues (n);
}
AddToChat (null, String.Format ("You have joined {0}.", thisRoom.Name));
if (room.HasPassword) {
AddToChat (null, "This chatroom is password-protected. Other users on the network who do not have the password are not able to evesdrop on the conversation.\n");
} else {
AddToChat (null, "This chatroom is not password-protected. Other users on the network are able to evesdrop on the conversation, regardless of if they appear to be in the room or not.\n");
}
base.SendMessage += base_SendMessage;
}
internal void AppendNetworkState(NetworkState stateObject)
{
if (stateObject.KnownConnections != null) {
foreach (ConnectionInfo connection in stateObject.KnownConnections) {
this.ProcessNewConnection (connection);
}
}
if (stateObject.KnownChatRooms != null) {
foreach (ChatRoomInfo roomInfo in stateObject.KnownChatRooms) {
lock (chatRooms) {
if (!chatRooms.ContainsKey(roomInfo.Id)) {
ChatRoom newRoom = new ChatRoom(this, roomInfo);
AddChatRoom(newRoom);
}
}
ChatRoom realRoom = chatRooms[roomInfo.Id];
foreach (string nodeId in roomInfo.Users) {
Node currentNode = GetNode(nodeId);
if (currentNode != null) {
if (!realRoom.Users.ContainsKey(currentNode.NodeID)) {
if (currentNode.NodeID == Core.MyNodeID) {
// err.. but.. i'm not in here!!
LoggingService.LogWarning("Someone thought I was in {0} but I'm not!!", realRoom.Name);
this.LeaveChat(realRoom);
} else {
realRoom.AddUser(currentNode);
OnJoinedChat (new ChatEventArgs (currentNode, realRoom));
}
}
} else {
LoggingService.LogWarning("TRIED TO ADD NON-EXISTANT NODE {0} TO CHATROOM {1}", nodeId, roomInfo.Name);
}
}
}
}
if (stateObject.KnownMemos != null) {
foreach (MemoInfo memoInfo in stateObject.KnownMemos) {
lock (memos) {
if (memos.ContainsKey(memoInfo.ID)) {
Memo existingMemo = memos[memoInfo.ID];
existingMemo.Subject = memoInfo.Subject;
existingMemo.Text = memoInfo.Text;
OnMemoUpdated (existingMemo);
} else {
Memo memo = new Memo (this, memoInfo);
AddMemo(memo);
}
}
}
}
}
internal void AddChatRoom(ChatRoom room)
{
lock (chatRooms) {
chatRooms.Add(room.Id, room);
}
}
public void SendChatMessage(ChatRoom room, string messageText)
{
if (room.InRoom == true) {
if (room.HasPassword) {
byte[] saltBytes = System.Text.Encoding.UTF8.GetBytes(room.Id);
SendBroadcast(MessageBuilder.CreateChatMessageMessage(room, Security.Encryption.PasswordEncrypt(room.Password, messageText, saltBytes)), LocalNode);
} else {
SendBroadcast(MessageBuilder.CreateChatMessageMessage(room, messageText), LocalNode);
}
} else {
throw new Exception("You cannot send messages to chatrooms that you are not in");
}
}
internal void ProcessChatMessage(Node messageFrom, ChatMessage message)
{
ChatRoom c = network.GetChatRoom(message.RoomId);
if (messageFrom != null) {
if (c == null) {
c = new ChatRoom (network, message.RoomId, message.RoomName);
network.AddChatRoom(c);
LoggingService.LogWarning("MessageProcessor: Assuming chat room {0} exists and that somebody will be joining it in a moment...", c.Name);
}
if (!c.Users.ContainsKey(messageFrom.NodeID)) {
LoggingService.LogWarning("MessageProcessor: Assuming {0} is in {1}...", messageFrom.NickName, c.Name);
c.AddUser(messageFrom);
network.RaiseJoinedChat (messageFrom, c);
}
if (c.InRoom == true) {
string messageText = message.Message;
if (c.HasPassword) {
try {
byte[] saltBytes = System.Text.Encoding.UTF8.GetBytes(c.Id);
messageText = Security.Encryption.PasswordDecrypt(c.Password, messageText, saltBytes);
} catch (Exception) {
messageText = "<UNABLE TO DECRYPT MESSAGE>";
}
}
network.RaiseChatMessage (c, messageFrom, messageText);
}
} else {
throw new Exception("A chat message was Received from a non existing user! (NodeID: " + messageFrom + ")");
}
}
public Message CreateChatInviteMessage(Node messageTo, ChatRoom room, string message, string password)
{
Message p = new Message(network, MessageType.ChatInvite);
p.To = messageTo.NodeID;
ChatInviteInfo c = new ChatInviteInfo();
c.RoomId = room.Id;
c.RoomName = room.Name;
c.Message = message;
c.Password = password;
p.Content = c;
return p;
}
public Message CreateChatMessageMessage(ChatRoom room, string messageText)
{
Message p = new Message(network, MessageType.ChatroomMessage);
ChatMessage c = new ChatMessage();
c.RoomId = room.Id;
c.RoomName = room.Name;
c.Message = messageText;
// p.To = "";
p.Content = c;
return p;
}
public void JoinChat(ChatRoom room, string password)
{
if (!room.TestPassword(password))
throw new ArgumentException("Incorrect password");
room.Password = password;
JoinChat(room);
}
internal void RemoveChatRoom(ChatRoom room)
{
lock (chatRooms) {
chatRooms.Remove(room.Id);
}
}
internal void RaiseLeftChat(Node node, ChatRoom room)
{
OnLeftChat (new ChatEventArgs (node, room));
}
internal void RaiseJoinedChat(Node node, ChatRoom room)
{
OnJoinedChat (new ChatEventArgs (node, room));
}
/*
internal void RaiseFileOffered (Node messageFrom, SharedFileInfo file)
{
OnFileOffered (new FileOfferedEventArgs (messageFrom, file));
}
protected virtual void OnFileOffered (FileOfferedEventArgs args)
{
if (FileOffered != null) {
FileOffered (this, args);
}
}
*/
internal void RaiseChatMessage(ChatRoom room, Node messageFrom, string messageText)
{
if (ChatMessage != null)
ChatMessage(room, messageFrom, messageText);
}
internal void ProcessJoinChatMessage(Node messageFrom, ChatAction action)
{
if (action.RoomName != null && action.RoomName.StartsWith("#")) {
ChatRoom c;
if (!network.HasChatRoom(action.RoomId)) {
c = new ChatRoom(network, action.RoomId, action.RoomName);
network.AddChatRoom(c);
} else {
c = network.GetChatRoom(action.RoomId);
}
if (!c.Users.ContainsKey(messageFrom.NodeID)) {
c.AddUser(messageFrom);
network.RaiseJoinedChat (messageFrom, c);
}
// Node n = network.Nodes[action.NodeID];
// if (n != null) {
// if (c.Users[n.NodeID] == null) {
// c.Users.Add(n);
// network.RaiseJoinedChat (n, c);
// }
// } else {
//
// }
}
}
private void network_ChatMessage(ChatRoom room, Node node, string text)
{
try {
if (room.InRoom == true) {
(room.Properties["Window"] as ChatRoomSubpage).AddToChat (node, text);
}
} catch (Exception ex) {
LoggingService.LogError(ex);
Gui.ShowErrorDialog (ex.ToString(), Gui.MainWindow.Window);
}
}
/*
private void network_FileOffered (Network network, FileOfferedEventArgs args)
{
try {
LogManager.Current.WriteToLog (args.From.NickName + " offers to send you " + args.File.FileName);
MessageDialog dialog = new MessageDialog (null,
DialogFlags.Modal,
Gtk.MessageType.Question,
ButtonsType.YesNo,
"{0} would like to send you the following file:\n\n{1}\n\nDo you want to accept it?",
args.From.ToString(),
args.File.FileName);
dialog.Show ();
if (dialog.Run() == (int)Gtk.ResponseType.Yes) {
//network.DownloadFile (args.From, args.File.FileFullPath, args.File.File.Size);
}
dialog.Destroy ();
} catch (Exception ex) {
LoggingService.LogError(ex);
Gui.ShowErrorDialog (ex.ToString(), Gui.MainWindow.Window);
}
}
*/
private void network_ReceivedChatInvite(Network network, Node inviteFrom, ChatRoom room, ChatInviteInfo invitation)
{
try {
ChatRoomInvitationDialog dialog = new ChatRoomInvitationDialog (network, inviteFrom, room, invitation);
dialog.Show ();
} catch (Exception ex) {
LoggingService.LogError(ex);
Gui.ShowErrorDialog (ex.ToString(), Gui.MainWindow.Window);
}
}
public void JoinChat(ChatRoom room)
{
if (room == null) {
throw new ArgumentNullException ("room");
}
lock (chatRooms) {
if (!room.Users.ContainsKey(this.LocalNode.NodeID)) {
room.AddUser(this.LocalNode);
SendBroadcast(MessageBuilder.CreateJoinChatMessage(room), this.LocalNode);
OnJoinedChat(new ChatEventArgs(this.LocalNode, room));
} else {
throw new Exception("Already in room");
}
}
}
public ChatEventArgs(Node node, ChatRoom room)
{
this.node = node;
this.room = room;
}
public void JoinOrCreateChat(string name, string password)
{
string roomId = String.IsNullOrEmpty(password) ? Common.SHA512Str(name) : Common.SHA512Str(name + password);
lock (chatRooms) {
ChatRoom room = null;
if (chatRooms.ContainsKey(roomId)) {
room = chatRooms[roomId];
} else {
room = new ChatRoom(this, roomId, name);
AddChatRoom(room);
}
JoinChat(room, password);
}
}
public Message CreateLeaveChatMessage(ChatRoom room)
{
Message p = new Message(network, MessageType.LeaveChat);
ChatAction c = new ChatAction();
c.RoomId = room.Id;
c.RoomName = room.Name;
p.Content = c;
return p;
}
/*
internal void JoinChat(string roomId, string roomName)
{
JoinChat(roomId, roomName, null);
}
internal void JoinChat(string roomName, string roomId, string password)
{
lock (chatRooms) {
ChatRoom room;
if (!chatRooms.ContainsKey(roomId)) {
room = new ChatRoom (this, roomId, roomName);
AddChatRoom(c);
} else {
c = chatRooms[roomId];
if (c.PasswordTest == "") {
throw new Exception("That chatroom is not password-protected.");
}
if (c.TestPassword(password) == false) {
throw new PasswordIncorrectException();
}
}
}
c.Password = password;
if (!c.Users.ContainsKey(LocalNode.NodeID)) {
c.AddUser(LocalNode);
SendBroadcast(MessageBuilder.CreateJoinChatMessage(c.Name), LocalNode);
OnJoinedChat (new ChatEventArgs (LocalNode, c));
}
}
*/
public void LeaveChat(ChatRoom room)
{
SendBroadcast(MessageBuilder.CreateLeaveChatMessage(room), LocalNode);
room.RemoveUser(LocalNode);
OnLeftChat (new ChatEventArgs (LocalNode, room));
if (room.Users.Count == 0) {
RemoveChatRoom(room);
}
}
public void SendChatInvitation(Node node, ChatRoom room, string message, string password)
{
Message m = MessageBuilder.CreateChatInviteMessage(node, room, message, password);
SendRoutedMessage (m);
}
public JoinChatroomDialog(Window parent, ChatRoom room)
: this(parent)
{
roomNameCombo.Entry.Text = room.Name;
roomNameCombo.Sensitive = false;
}
