v1.2

FSI.BT.Tools/TimeStampToClipboard/Business/App.cs

@@ -0,0 +1,34 @@
+// <copyright file="App.cs" company="PlaceholderCompany">
+// Copyright (c) PlaceholderCompany. All rights reserved.
+// </copyright>
+using System;
+using Microsoft.Win32;
+using FSI.BT.Tools.TimeStampToClipboard.Business;
+using FSI.BT.Tools.Global.Utilities;
+
+namespace FSI.BT.Tools.TimeStampToClipboard
+{
+    /// <summary>
+    /// App contains the notifyicon, the taskbarform and the menus.
+    /// </summary>
+    internal class App : IDisposable
+    {
+        private readonly Main menus = new();
+
+        public App()
+        {
+            AppRestart.BeforeRestarting += Dispose;
+            SystemEvents.DisplaySettingsChanged += SystemEvents_DisplaySettingsChanged;
+        }
+
+        public void Dispose()
+        {
+          
+        }
+
+        private void SystemEvents_DisplaySettingsChanged(object sender, EventArgs e)
+        {
+          
+        }        
+    }
+}

FSI.BT.Tools/TimeStampToClipboard/Business/KeyboardInput.cs

@@ -0,0 +1,56 @@
+// <copyright file="KeyboardInput.cs" company="PlaceholderCompany">
+// Copyright (c) PlaceholderCompany. All rights reserved.
+// </copyright>
+
+using FSI.BT.Tools.TimeStampToClipboard.Helper;
+using System;
+
+namespace FSI.BT.Tools.TimeStampToClipboard.Handler
+{
+    internal class KeyboardInput : IDisposable
+    {
+    
+        private readonly KeyboardHook hook = new();
+
+        private int iRowKey = -1;
+        private int iMenuKey;
+
+        public KeyboardInput()
+        {
+        }
+
+        public event Action HotKeyPressed;
+
+     
+
+        public void Dispose()
+        {
+            hook.KeyPressed -= Hook_KeyPressed;
+            hook.Dispose();
+        }
+
+        public void RegisterHotKey()
+        {
+            if (!string.IsNullOrEmpty(Global.Vars.TimeStampSettings.HotKey))
+            {
+                try
+                {
+                    hook.RegisterHotKey();
+                    hook.KeyPressed += Hook_KeyPressed;
+                }
+                catch (InvalidOperationException ex)
+                {
+                    //Log.Warn($"key:'{Properties.Settings.Default.HotKey}'", ex);
+                    Global.Vars.TimeStampSettings.HotKey = string.Empty;
+                    //Properties.Settings.Default.Save();
+                }
+            }
+        }
+
+     
+        private void Hook_KeyPressed(object sender, FSI.BT.Tools.TimeStampToClipboard.Helper.KeyPressedEventArgs e)
+        {
+            HotKeyPressed?.Invoke();
+        }
+    }
+}

FSI.BT.Tools/TimeStampToClipboard/Business/Menus.cs

@@ -0,0 +1,57 @@
+namespace FSI.BT.Tools.TimeStampToClipboard.Business
+{
+    using System;
+    using System.Drawing;
+    using System.Threading;
+    using System.Windows;
+    using FSI.BT.Tools.TimeStampToClipboard.Handler;
+    using Tulpep.NotificationWindow;
+    using Windows.Data.Xml.Dom;
+    using Windows.UI.Notifications;
+
+    internal class Main : IDisposable
+    {
+
+        private readonly KeyboardInput keyboardInput;
+
+        public Main()
+        {
+            keyboardInput = new();
+            keyboardInput.RegisterHotKey();
+            keyboardInput.HotKeyPressed += KeyboardInput_HotKeyPressed;
+        }
+
+        public event Action LoadStarted;
+
+        public event Action LoadStopped;
+
+        public void Dispose()
+        {
+            keyboardInput.HotKeyPressed -= KeyboardInput_HotKeyPressed;
+            keyboardInput.Dispose();
+        }
+
+        private void KeyboardInput_HotKeyPressed()
+        {
+            var timeStampFormat = Global.Vars.TimeStampSettings.Format;
+            System.Windows.Forms.Clipboard.SetDataObject(DateTime.Now.ToString(timeStampFormat));
+            //Global.Log.Debug("Zeitstempel \"{0}\" wurde in die Zwischenablage kopiert.", DateTime.Now.ToString(timeStampFormat));
+
+            PopupNotifier popup = new PopupNotifier();
+
+            popup.BodyColor = Color.FromArgb(40, 167, 69);
+            popup.Image = SystemTrayMenu.Properties.Resources.SystemTrayMenu.ToBitmap();
+            popup.TitleText = "Zeitstempel";
+            popup.TitleColor = Color.White;
+            popup.TitleFont = new Font("Century Gothic", 15, System.Drawing.FontStyle.Bold);
+
+            popup.ContentText = "Zeitstempel wurde in die Zwischenablage kopiert";
+            popup.ContentColor = Color.White;
+            popup.ContentFont = new Font("Century Gothic", 12);
+            popup.Popup();
+
+        }
+
+
+    }
+}

FSI.BT.Tools/TimeStampToClipboard/Helpers/KeyPressedEventArgs.cs

@@ -0,0 +1,27 @@
+// <copyright file="KeyPressedEventArgs.cs" company="PlaceholderCompany">
+// Copyright (c) PlaceholderCompany. All rights reserved.
+// </copyright>
+
+namespace FSI.BT.Tools.TimeStampToClipboard.Helper
+{
+    using System;
+    using System.Windows.Forms;
+
+    /// <summary>
+    /// Event Args for the event that is fired after the hot key has been pressed.
+    /// </summary>
+    internal class KeyPressedEventArgs : EventArgs
+    {
+        private readonly Keys key;
+
+        internal KeyPressedEventArgs(KeyboardHookModifierKeys modifier, Keys key)
+        {
+            Modifier = modifier;
+            this.key = key;
+        }
+
+        internal KeyboardHookModifierKeys Modifier { get; }
+
+        internal Keys Key => key;
+    }
+}

FSI.BT.Tools/TimeStampToClipboard/Helpers/KeyboardHook.cs

@@ -0,0 +1,166 @@
+// <copyright file="KeyboardHook.cs" company="PlaceholderCompany">
+// Copyright (c) PlaceholderCompany. All rights reserved.
+// </copyright>
+
+namespace FSI.BT.Tools.TimeStampToClipboard.Helper
+{
+    using System;
+    using System.Windows.Forms;
+    using FSI.BT.Tools.Global.DllImports;
+    using FSI.BT.Tools.Global.UserInterface.HotkeyTextboxControl;
+
+    /// <summary>
+    /// The enumeration of possible modifiers.
+    /// </summary>
+    [Flags]
+    public enum KeyboardHookModifierKeys : uint
+    {
+        None = 0,
+        Alt = 1,
+        Control = 2,
+        Shift = 4,
+        Win = 8,
+    }
+
+    public sealed class KeyboardHook : IDisposable
+    {
+        private readonly Window window = new();
+        private int currentId;
+
+        public KeyboardHook()
+        {
+            // register the event of the inner native window.
+            window.KeyPressed += Window_KeyPressed;
+        }
+
+        /// <summary>
+        /// A hot key has been pressed.
+        /// </summary>
+        internal event EventHandler<KeyPressedEventArgs> KeyPressed;
+
+        public void Dispose()
+        {
+            // unregister all the registered hot keys.
+            for (int i = currentId; i > 0; i--)
+            {
+                Global.DllImports.NativeMethods.User32UnregisterHotKey(window.Handle, i);
+            }
+
+            // dispose the inner native window.
+            window.KeyPressed -= Window_KeyPressed;
+            window.Dispose();
+        }
+
+        /// <summary>
+        /// Registers a hot key in the system.
+        /// </summary>
+        /// <param name="key">The key itself that is associated with the hot key.</param>
+        internal void RegisterHotKey(Keys key)
+        {
+            uint keyModifiersNone = 0;
+            RegisterHotKey(keyModifiersNone, key);
+        }
+
+        internal void RegisterHotKey()
+        {
+            KeyboardHookModifierKeys modifiers = KeyboardHookModifierKeys.None;
+            string modifiersString = Global.Vars.TimeStampSettings.HotKey;
+            if (!string.IsNullOrEmpty(modifiersString))
+            {
+                if (modifiersString.ToUpperInvariant().Contains("ALT", StringComparison.InvariantCulture))
+                {
+                    modifiers |= KeyboardHookModifierKeys.Alt;
+                }
+
+                if (modifiersString.ToUpperInvariant().Contains("CTRL", StringComparison.InvariantCulture) ||
+                    modifiersString.ToUpperInvariant().Contains("STRG", StringComparison.InvariantCulture))
+                {
+                    modifiers |= KeyboardHookModifierKeys.Control;
+                }
+
+                if (modifiersString.ToUpperInvariant().Contains("SHIFT", StringComparison.InvariantCulture))
+                {
+                    modifiers |= KeyboardHookModifierKeys.Shift;
+                }
+
+                if (modifiersString.ToUpperInvariant().Contains("WIN", StringComparison.InvariantCulture))
+                {
+                    modifiers |= KeyboardHookModifierKeys.Win;
+                }
+            }
+
+            RegisterHotKey(
+                modifiers,
+                HotkeyControl.HotkeyFromString(
+                    Global.Vars.TimeStampSettings.HotKey));
+        }
+
+        /// <summary>
+        /// Registers a hot key in the system.
+        /// </summary>
+        /// <param name="modifier">The modifiers that are associated with the hot key.</param>
+        /// <param name="key">The key itself that is associated with the hot key.</param>
+        internal void RegisterHotKey(KeyboardHookModifierKeys modifier, Keys key)
+        {
+            RegisterHotKey((uint)modifier, key);
+        }
+
+        private void Window_KeyPressed(object sender, FSI.BT.Tools.TimeStampToClipboard.Helper.KeyPressedEventArgs e)
+        {
+            KeyPressed?.Invoke(this, e);
+        }
+
+        private void RegisterHotKey(uint modifier, Keys key)
+        {
+            currentId += 1;
+
+            if (!NativeMethods.User32RegisterHotKey(
+                window.Handle, currentId, modifier, (uint)key))
+            {
+                throw new InvalidOperationException(
+                    Global.Utilities.Translator.GetText("Could not register the hot key."));
+            }
+        }
+
+        /// <summary>
+        /// Represents the window that is used internally to get the messages.
+        /// </summary>
+        private class Window : NativeWindow, IDisposable
+        {
+            private const int WmHotkey = 0x0312;
+
+            public Window()
+            {
+                // create the handle for the window.
+                CreateHandle(new CreateParams());
+            }
+
+            public event EventHandler<FSI.BT.Tools.TimeStampToClipboard.Helper.KeyPressedEventArgs> KeyPressed;
+
+            public void Dispose()
+            {
+                DestroyHandle();
+            }
+
+            /// <summary>
+            /// Overridden to get the notifications.
+            /// </summary>
+            /// <param name="m">m.</param>
+            protected override void WndProc(ref Message m)
+            {
+                base.WndProc(ref m);
+
+                // check if we got a hot key pressed.
+                if (m.Msg == WmHotkey)
+                {
+                    // get the keys.
+                    Keys key = (Keys)(((int)m.LParam >> 16) & 0xFFFF);
+                    KeyboardHookModifierKeys modifier = (KeyboardHookModifierKeys)((int)m.LParam & 0xFFFF);
+
+                    // invoke the event to notify the parent.
+                    KeyPressed?.Invoke(this, new KeyPressedEventArgs(modifier, key));
+                }
+            }
+        }
+    }
+}

FSI.BT.Tools/TimeStampToClipboard/Settings/IInterface.cs

@@ -0,0 +1,24 @@
+using Config.Net;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace FSI.BT.Tools.TimeStampToClipboard.Settings
+{
+    public class Interface
+    {
+        public interface IInterface
+        {
+            [Option(DefaultValue = "Alt+Ctrl+C")]
+            string HotKey { get; set; }
+
+            [Option(DefaultValue = "_yyyyMMdd_HHmmss")]
+            string Format { get; set; }
+
+            [Option(DefaultValue = "false")]
+            bool SendHotkeyInsteadKillOtherInstances { get; set; }
+        }
+    }
+}