private async Task SendFile()
        {
            if (this.client.isConnected)
            {
                fileDialog = new OpenFileDialog();
                fileDialog.ShowDialog();
                fileDialog.DefaultExt = ".png";
                fileDialog.Filter     = "JPEG Files (*.jpeg)|*.jpeg|PNG Files (*.png)|*.png|JPG Files (*.jpg)|*.jpg|GIF Files (*.gif)|*.gif";

                string      filePath    = fileDialog.FileName;
                ImagePacket imagePacket = new ImagePacket();
                imagePacket.Imagebmp       = new System.Drawing.Bitmap(filePath);
                imagePacket.isPersonal     = true;
                imagePacket.sender         = this.client.Username;
                imagePacket.targetUsername = targetUsername;

                this.client.TrySendObject(imagePacket);

                BitmapToImageConverter bmpConverter = new BitmapToImageConverter();
                var image = bmpConverter.Convert(imagePacket.Imagebmp);

                messages.Add(new ViewItemModel()
                {
                    bmpImage = (BitmapImage)image, message = client.Username + "sent and Image!"
                });
            }
            else
            {
                messages.Add(new ViewItemModel()
                {
                    message = "Not connected"
                });
            }
        }
Exemplo n.º 2
0
        public void AddImage(ImagePacket imgPacket)
        {
            BitmapToImageConverter converter = new BitmapToImageConverter();
            var receivedImage = converter.Convert(imgPacket.Imagebmp);

            viewModel.AddMessage(new ViewItemModel()
            {
                bmpImage = (BitmapImage)receivedImage, message = imgPacket.sender + " sent an Image!"
            });

            //add autoscrolling when first collection message is added
            if (viewModel.messages.Count == 1)
            {
                AddAutoScrolling();
            }
        }
        public void CreatePersonalWindow(string target, object Packet)
        {
            App.Current.Dispatcher.Invoke((Action) delegate
            {
                PersonalChatWindow personalWindow = new PersonalChatWindow(this.client, target);
                PersonalWindows.Add(target, personalWindow);
                if (Packet is ImagePacket imgPacket)
                {
                    BitmapToImageConverter converter = new BitmapToImageConverter();
                    var receivedImage = converter.Convert(imgPacket.Imagebmp);

                    personalWindow.AddImage((BitmapImage)receivedImage);
                    Application.Current.Properties["personalWindows"] = PersonalWindows;
                    personalWindow.Show();
                }
                else if (Packet is MessagePacket Message)
                {
                    personalWindow.AddMessage(Message.message);
                    Application.Current.Properties["personalWindows"] = PersonalWindows;
                    personalWindow.Show();
                }
            });
        private async Task SendFile()
        {
            if (this.client.isConnected)
            {
                try
                {
                    ImagePacket imagePacket = new ImagePacket();
                    imagePacket.Imagebmp       = new System.Drawing.Bitmap(filePath);
                    imagePacket.isPersonal     = true;
                    imagePacket.sender         = this.client.Username;
                    imagePacket.targetUsername = targetUsername;
                    try
                    {
                        await this.client.TrySendObject(imagePacket);
                    }
                    catch
                    {
                        if (this.client.requestDisconnection)
                        {
                            AddMessage(new ViewItemModel()
                            {
                                message = "You have been disconnected."
                            });
                        }
                        else
                        {
                            AddMessage(new ViewItemModel()
                            {
                                message = "You have been forcefully disconnected. Try to reconnect from the main window."
                            });
                        }
                    }
                    finally
                    {
                        filePath = string.Empty;
                    }
                    BitmapToImageConverter bmpConverter = new BitmapToImageConverter();
                    var image = bmpConverter.Convert(imagePacket.Imagebmp);

                    AddMessage(new ViewItemModel()
                    {
                        bmpImage = (BitmapImage)image, message = client.Username + "sent and Image!"
                    });
                }
                catch (ArgumentException)
                {
                    AddMessage(new ViewItemModel()
                    {
                        message = "File is not in a valid format, please send only  jpeg, png , gif or jpg files!"
                    });
                    filePath = string.Empty;
                }
            }
            else
            {
                AddMessage(new ViewItemModel()
                {
                    message = "Not connected"
                });
            }
            filePath = string.Empty;
        }
        private void UpdateUI(object message)
        {
            if (message != null)
            {
                if (message is string disconnectionReason)
                {
                    App.Current.Dispatcher.Invoke((Action) delegate
                    {
                        messages.Add(new ViewItemModel {
                            message = disconnectionReason
                        });
                    });
                }
                else if (message is List <string> users)
                {
                    App.Current.Dispatcher.Invoke((Action) delegate
                    {
                        CurrentUsers.Clear();
                        foreach (string user in users)
                        {
                            if (user != Username)
                            {
                                Button userButton           = new Button();
                                userButton.Content          = user;
                                userButton.CommandParameter = user;
                                userButton.Command          = OpenPersonalWindow;

                                if (PersonalWindows.ContainsKey(user))
                                {
                                    userButton.IsEnabled = false;
                                }
                                CurrentUsers.Add(userButton);
                            }
                        }
                    });
                }
                else if (message is MessagePacket Message)
                {
                    if (Message.targetUsername == Username && Message.isPersonal == true)
                    {
                        if (PersonalWindows.ContainsKey(Message.sender))
                        {
                            App.Current.Dispatcher.Invoke((Action) delegate
                            {
                                PersonalWindows[Message.sender].AddMessage(Message.message);
                            });
                        }
                        else
                        {
                            App.Current.Dispatcher.Invoke((Action) delegate
                            {
                                CreatePersonalWindow(Message.sender, Message);
                            });
                        }
                    }
                    else
                    {
                        App.Current.Dispatcher.Invoke((Action) delegate
                        {
                            messages.Add(new ViewItemModel()
                            {
                                message = Message.sender + ": " + Message.message
                            });
                        });
                    }
                }
                else if (message is ImagePacket imgPacket)
                {
                    if (imgPacket.isPersonal == true && imgPacket.targetUsername == Username)
                    {
                        if (PersonalWindows.ContainsKey(imgPacket.sender))
                        {
                            App.Current.Dispatcher.Invoke((Action) delegate
                            {
                                BitmapToImageConverter converter = new BitmapToImageConverter();
                                var receivedImage = converter.Convert(imgPacket.Imagebmp);

                                PersonalWindows[imgPacket.sender].AddImage((BitmapImage)receivedImage);
                            });
                        }
                        else
                        {
                            App.Current.Dispatcher.Invoke((Action) delegate
                            {
                                CreatePersonalWindow(imgPacket.sender, imgPacket);
                            });
                        }
                    }
                    else
                    {
                        App.Current.Dispatcher.Invoke((Action) delegate
                        {
                            BitmapToImageConverter converter = new BitmapToImageConverter();
                            var receivedImage = converter.Convert(imgPacket.Imagebmp);

                            messages.Add(new ViewItemModel()
                            {
                                bmpImage = (BitmapImage)receivedImage, message = imgPacket.sender + " sent an Image!"
                            });
                        });
                    }
                }
            }
            else
            {
                return;
            }
        }
        private async Task UpdateUI(Package message)
        {
            if (message != null)
            {
                if (message is DisconnectionPackage dcPackage)
                {
                    AddMessage(new ViewItemModel {
                        message = dcPackage.reason
                    });
                    UpdatePersonalWindows();
                    CurrentUsers.Clear();
                    await client.TryDisconnect(); //sets request disconnection to true

                    client.requestDisconnection = false;
                }
                else if (message is UsersPacket users)
                {
                    CurrentUsers.Clear();
                    foreach (string user in users.Usernames)
                    {
                        UpdateConnectedUsers(user);
                    }
                }
                else if (message is MessagePacket Message)
                {
                    if (Message.targetUsername == Username && Message.isPersonal == true)
                    {
                        if (PersonalWindows.ContainsKey(Message.sender))
                        {
                            PersonalWindows[Message.sender].AddMessage(Message);
                        }
                        else
                        {
                            CreatePersonalWindow(Message.sender, Message);
                        }
                    }
                    else
                    {
                        AddMessage(new ViewItemModel()
                        {
                            message = Message.sender + ": " + Message.message
                        });
                    }
                }
                else if (message is ImagePacket imgPacket)
                {
                    if (imgPacket.isPersonal == true && imgPacket.targetUsername == Username)
                    {
                        if (PersonalWindows.ContainsKey(imgPacket.sender))
                        {
                            PersonalWindows[imgPacket.sender].AddImage(imgPacket);
                        }
                        else
                        {
                            CreatePersonalWindow(imgPacket.sender, imgPacket);
                        }
                    }
                    else
                    {
                        BitmapToImageConverter converter = new BitmapToImageConverter();
                        var receivedImage = converter.Convert(imgPacket.Imagebmp);

                        AddMessage(new ViewItemModel()
                        {
                            bmpImage = (BitmapImage)receivedImage, message = imgPacket.sender + " sent an Image!"
                        });
                    }
                }
            }
            else
            {
                return;
            }
        }