Hush – Diff between revs 1 and 2

Subversion Repositories:

?pathlinks?

Rev 1 – Rev 3 – Go to most recent revision – Details – Blame – Last modification – View Log

 using System.Linq;
 using System.Net;
 using System.Threading;
 using System.Threading.Tasks;
 using System.Windows.Forms;
+using Gma.System.MouseKeyHook;
+using Hush.Chat;
 using Hush.Communication;
 using Hush.Discovery;
-using Hush.Lobby;
 using Hush.Properties;
 using Hush.Utilities;
 using WingMan.Communication;
+using Message = System.Windows.Forms.Message;
 namespace Hush
+{
     public partial class Hush : Form
             InitializeComponent();
             FormTaskScheduler = TaskScheduler.FromCurrentSynchronizationContext();
+            FormCancellationTokenSource = new CancellationTokenSource();
+            // Initialize a message buffer.
-            FormCancellationTokenSource = new CancellationTokenSource();
+            Messages = new List<string>();
             // Bind to settings changed event.
             Settings.Default.SettingsLoaded += DefaultOnSettingsLoaded;
+            Settings.Default.SettingsSaving += DefaultOnSettingsSaving;
+            Settings.Default.PropertyChanged += DefaultOnPropertyChanged;
+            // Set up keyboard hook.
-            Settings.Default.SettingsSaving += DefaultOnSettingsSaving;
+            MouseKeyGlobalHook = Hook.GlobalEvents();
-            Settings.Default.PropertyChanged += DefaultOnPropertyChanged;
+            MouseKeyGlobalHook.KeyDown += MouseKeyGlobalHookOnKeyDown;
             // Set up discovery.
-            Discovery = new Discovery.Discovery(Constants.ASSEMBLY_NAME, FormCancellationTokenSource,
+            Discovery = new Discovery.Discovery(Constants.AssemblyName, FormCancellationTokenSource.Token,
                 FormTaskScheduler);
+            Discovery.OnPortMapFailed += OnDiscoveryPortMapFailed;
-            Discovery.OnPortMapFailed += OnDiscoveryPortMapFailed;
+            // Bind to MQTT events.
-            // Bind to MQTT events.
+            MqttCommunication = new MqttCommunication(FormTaskScheduler, FormCancellationTokenSource.Token);
-            MqttCommunication = new MqttCommunication(FormTaskScheduler, FormCancellationTokenSource.Token);
+            // TODO implement events.
-            //mqttCommunication.
+            //MqttCommunication.
+            // Start message synchronizer.
-            // Start lobby message synchronizer.
+            ChatMessageSynchronizer = new ChatMessageSynchronizer(Constants.MqttTopic, MqttCommunication, FormTaskScheduler,
-            LobbyMessageSynchronizer = new LobbyMessageSynchronizer(MqttCommunication, FormTaskScheduler,
+                FormCancellationTokenSource.Token);
-                FormCancellationTokenSource.Token);
+            ChatMessageSynchronizer.OnMessageReceived += OnMessageReceived;
-            LobbyMessageSynchronizer.OnLobbyMessageReceived += OnLobbyMessageReceived;
+        }
+        private static IKeyboardMouseEvents MouseKeyGlobalHook { get; set; }
+        private static TaskScheduler FormTaskScheduler { get; set; }
+        private static CancellationTokenSource FormCancellationTokenSource { get; set; }
+        private static MqttCommunication MqttCommunication { get; set; }
+        private static ChatMessageSynchronizer ChatMessageSynchronizer { get; set; }
+        private static Discovery.Discovery Discovery { get; set; }
+        private static List<string> Messages { get; set; }
+        private void MouseKeyGlobalHookOnKeyDown(object sender, KeyEventArgs keyEventArgs)
+        {
+            // Bind to CTRL+C
             if (!keyEventArgs.Control || keyEventArgs.KeyCode != Keys.C)
-        private static TaskScheduler FormTaskScheduler { get; set; }
+                return;
         private static CancellationTokenSource FormCancellationTokenSource { get; set; }
-        private static MqttCommunication MqttCommunication { get; set; }
+            ActiveControl = messageTextBox;
-        private static LobbyMessageSynchronizer LobbyMessageSynchronizer { get; set; }
+            messageTextBox.Focus();
         private static Discovery.Discovery Discovery { get; set; }
         private void OnDiscoveryPortMapFailed(object sender, DiscoveryFailedEventArgs args)
+        {
+            notifyIcon1.BalloonTipIcon = ToolTipIcon.Warning;
+            notifyIcon1.BalloonTipTitle = Strings.Network_warning;
+            notifyIcon1.BalloonTipText = Strings.Failed_to_create_automatic_NAT_port_mapping;
+            notifyIcon1.ShowBalloonTip(1000);
+        }
+        private void OnMessageReceived(object sender, ChatMessageReceivedEventArgs e)
+        {
+            var message = $"{e.Nick} : {e.Message}";
+            Messages.Add(message);
-            notifyIcon1.BalloonTipIcon = ToolTipIcon.Warning;
-            notifyIcon1.BalloonTipTitle = Strings.Network_warning;
+            // Keep the content of the text box limited to the size of the displayed text.
-            notifyIcon1.BalloonTipText = Strings.Failed_to_create_automatic_NAT_port_mapping;
+            var lineHeight = TextRenderer.MeasureText(message, chatTextBox.Font).Height;
-            notifyIcon1.ShowBalloonTip(1000);
+            var linesPerPage = (int) Math.Ceiling(1.0f * chatTextBox.ClientSize.Height / lineHeight);
-        }
             if (Messages.Count > linesPerPage)
-        private void OnLobbyMessageReceived(object sender, LobbyMessageReceivedEventArgs e)
+                Messages.RemoveRange(0, Messages.Count - 1 - linesPerPage);
-            LobbyTextBox.AppendText($"{e.Nick} : {e.Message}{Environment.NewLine}");
+            chatTextBox.Text = string.Join(Environment.NewLine, Messages);
+        }
         private async Task StartClient()
+        {
             if (!IPAddress.TryParse(Settings.Default.Address, out var address))
                 try
+                {
+                    var getHostAddresses = await Dns.GetHostAddressesAsync(Settings.Default.Address);
+                    if (!getHostAddresses.Any())
+                        throw new Exception();
-                    address = Dns.GetHostAddresses(Settings.Default.Address).FirstOrDefault();
+                    address = getHostAddresses.FirstOrDefault();
+                }
                 catch
+                {
                     throw new ToolTippedException(ToolTipIcon.Error, Strings.Network_error,
                         $"{Strings.Unable_to_determine_address} {Settings.Default.Address}");
                 throw new ToolTippedException(ToolTipIcon.Error, Strings.Network_error, Strings.No_password_set);
             if (!await MqttCommunication
                 .Start(MqttCommunicationType.Client, address, (int) port, Settings.Default.Nick,
                     Settings.Default.Password,
-                    new[] {"lobby"}))
+                    new[] {Constants.MqttTopic}))
                 throw new ToolTippedException(ToolTipIcon.Error, Strings.Network_error, Strings.Unable_to_start_client);
+        }
                 FormCancellationTokenSource.Token, TaskContinuationOptions.LongRunning, FormTaskScheduler);
             // Start the MQTT server.
             if (!await MqttCommunication
                 .Start(MqttCommunicationType.Server, address, (int) port, Settings.Default.Nick,
-                    Settings.Default.Password, new[] {"lobby"}))
+                    Settings.Default.Password, new[] {Constants.MqttTopic}))
                 throw new ToolTippedException(ToolTipIcon.Error, Strings.Network_error, Strings.Unable_to_start_server);
+        }
         ///     Clean up any resources being used.
         /// </summary>
         /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
         protected override void Dispose(bool disposing)
+        {
+            // Unbind global key hook.
+            MouseKeyGlobalHook.KeyDown -= MouseKeyGlobalHookOnKeyDown;
+            // Unbind message synchronizer.
+            ChatMessageSynchronizer.OnMessageReceived -= OnMessageReceived;
             // Unbind settings handlers.
             Settings.Default.SettingsLoaded -= DefaultOnSettingsLoaded;
             Settings.Default.SettingsSaving -= DefaultOnSettingsSaving;
             Settings.Default.PropertyChanged -= DefaultOnPropertyChanged;
         private void OnMouseDown(object sender, MouseEventArgs e)
+        {
             if (e.Button == MouseButtons.Left)
             {
-                Natives.ReleaseCapture();
+                DllImports.ReleaseCapture();
-                Natives.SendMessage(Handle, Natives.WM_NCLBUTTONDOWN, Natives.HT_CAPTION, 0);
+                DllImports.SendMessage(Handle, DllImports.WM_NCLBUTTONDOWN, DllImports.HT_CAPTION, 0);
+            }
+        }
             if (!handled)
                 base.WndProc(ref m);
         }
-        private void OnMouseEnter(object sender, EventArgs e)
+        private void HushFocus(object sender, EventArgs e)
+        {
             Opacity = .75;
+        }
-        private void OnMouseLeave(object sender, EventArgs e)
+        private void HushUnfocus(object sender, EventArgs e)
+        {
             Application.Exit();
+        }
         private async void MessageTextBoxOnKeyDown(object sender, KeyEventArgs e)
         {
-            // Do not send messages if the communication is not running.
+            // Prevent the enter key to be passed to the text box or we get a nasty ding.
-            if (!MqttCommunication.Running)
+            if (e.KeyCode == Keys.Enter)
-                return;
+                e.SuppressKeyPress = true;
+            if (e.KeyCode != Keys.Enter)
+                return;
+            // Do not send messages if the communication is not running.
-            if (e.KeyCode != Keys.Enter)
+            if (!MqttCommunication.Running)
                 return;
             if (string.IsNullOrEmpty(messageTextBox.Text))
                 return;
             // Send the message
+        {
             var toolStripMenuItem = (ToolStripTextBox) sender;
             Settings.Default.Port = toolStripMenuItem.Text;
+        }
+        private void ChatTextBox_TextChanged(object sender, EventArgs e)
+        {
+            var textBox = (TextBox) sender;
+            textBox.ScrollToCaret();
+        }
+    }
+}