From e1cbdab192455f6ec06944bd314e91ef64bc6e3d Mon Sep 17 00:00:00 2001
From: Firav <firavv@gmail.com>
Date: Tue, 11 Nov 2025 12:37:13 -0500
Subject: [PATCH 01/13] add keybind manager to dropdown and update window close
 behavior

---
 WhackerLinkConsoleV2/App.xaml        | 3 ++-
 WhackerLinkConsoleV2/MainWindow.xaml | 4 +++-
 2 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/WhackerLinkConsoleV2/App.xaml b/WhackerLinkConsoleV2/App.xaml
index 48129b4..5f0455a 100644
--- a/WhackerLinkConsoleV2/App.xaml
+++ b/WhackerLinkConsoleV2/App.xaml
@@ -1,7 +1,8 @@
 <Application x:Class="WhackerLinkConsoleV2.App"
              xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
              xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
-             StartupUri="MainWindow.xaml">
+             StartupUri="MainWindow.xaml"
+             ShutdownMode="OnMainWindowClose">
     <Application.Resources>
         <!-- Default Button Style -->
         <Style TargetType="Button" x:Key="FlatButton">
diff --git a/WhackerLinkConsoleV2/MainWindow.xaml b/WhackerLinkConsoleV2/MainWindow.xaml
index 3cc66f8..538c4b9 100644
--- a/WhackerLinkConsoleV2/MainWindow.xaml
+++ b/WhackerLinkConsoleV2/MainWindow.xaml
@@ -2,7 +2,8 @@
         xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
         xmlns:local="clr-namespace:WhackerLinkConsoleV2.Controls"
-        Title="WhackerLinkConsoleV2" Height="600" Width="1000" Background="#FFF2F2F2">
+        Title="WhackerLinkConsoleV2" Height="600" Width="1000" Background="#FFF2F2F2"
+        Closed="MainWindow_OnClosed">
     <Grid Background="#FFF2F2F2">
         <Grid.ColumnDefinitions>
             <ColumnDefinition Width="497*"/>
@@ -29,6 +30,7 @@
             </MenuItem>
             <MenuItem Header="Edit">
                 <MenuItem Header="Audio Settings" Click="AudioSettings_Click" />
+                <MenuItem Header="Configure PTT Keybindings" Click="ConfigurePttKeybindings_Click"/>
                 <MenuItem Header="Enable Edit Mode" Click="ToggleEditMode_Click"/>
                 <MenuItem Header="Select Widgets to Display" Click="SelectWidgets_Click"/>
                 <MenuItem Header="Reset Settings" Click="ResetSettings_Click"/>

From d66d1b00eaca39797c04fb5c1a83170147cfdc20 Mon Sep 17 00:00:00 2001
From: Firav <firavv@gmail.com>
Date: Tue, 11 Nov 2025 12:42:01 -0500
Subject: [PATCH 02/13] Add classes for keybind management of global and
 channel hotkeys

---
 WhackerLinkConsoleV2/ChannelHotKeyManager.cs  | 178 ++++++++
 .../ChannelKeybindingManager.cs               | 214 +++++++++
 WhackerLinkConsoleV2/GlobalHotKeyManager.cs   | 417 ++++++++++++++++++
 WhackerLinkConsoleV2/KeybindingParser.cs      | 147 ++++++
 4 files changed, 956 insertions(+)
 create mode 100644 WhackerLinkConsoleV2/ChannelHotKeyManager.cs
 create mode 100644 WhackerLinkConsoleV2/ChannelKeybindingManager.cs
 create mode 100644 WhackerLinkConsoleV2/GlobalHotKeyManager.cs
 create mode 100644 WhackerLinkConsoleV2/KeybindingParser.cs

diff --git a/WhackerLinkConsoleV2/ChannelHotKeyManager.cs b/WhackerLinkConsoleV2/ChannelHotKeyManager.cs
new file mode 100644
index 0000000..1e1630d
--- /dev/null
+++ b/WhackerLinkConsoleV2/ChannelHotKeyManager.cs
@@ -0,0 +1,178 @@
+/*
+* WhackerLink - WhackerLinkConsoleV2
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program.  If not, see <http://www.gnu.org/licenses/>.
+* 
+* Copyright (C) 2024-2025 Caleb, K4PHP
+* Copyright (C) 2025 Firav (firavdev@gmail.com)
+* 
+*/
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Windows.Input;
+using WhackerLinkConsoleV2.Controls;
+
+namespace WhackerLinkConsoleV2
+{
+    /// <summary>
+    /// Manages per-channel PTT hotkey registrations and triggering
+    /// </summary>
+    public class ChannelHotKeyManager
+    {
+        private GlobalHotKeyManager _globalHotKeyManager;
+        private ChannelKeybindingManager _channelKeybindingManager;
+        private Dictionary<string, int> _channelHotKeyIds = new Dictionary<string, int>();
+        private Dictionary<int, string> _hotKeyIdToChannelName = new Dictionary<int, string>();
+        private List<ChannelBox> _allChannels = new List<ChannelBox>();
+        private string _currentCodeplugIdentifier;
+        private Action<ChannelBox, bool> _onChannelPttTriggered;
+
+        public ChannelHotKeyManager(GlobalHotKeyManager globalHotKeyManager, ChannelKeybindingManager channelKeybindingManager, Action<ChannelBox, bool> onChannelPttTriggered)
+        {
+            _globalHotKeyManager = globalHotKeyManager;
+            _channelKeybindingManager = channelKeybindingManager;
+            _onChannelPttTriggered = onChannelPttTriggered;
+        }
+
+        /// <summary>
+        /// Initializes channel hotkeys for the current codeplug
+        /// </summary>
+        public void InitializeChannelHotkeys(string codeplugIdentifier, List<ChannelBox> channels)
+        {
+            // Unregister old hotkeys if codeplug changed
+            if (_currentCodeplugIdentifier != codeplugIdentifier)
+            {
+                UnregisterAllChannelHotkeys();
+                _currentCodeplugIdentifier = codeplugIdentifier;
+            }
+
+            _allChannels = channels;
+
+            // Register hotkeys for channels that have keybindings
+            int registeredCount = 0;
+            foreach (var channel in channels)
+            {
+                var keybinding = _channelKeybindingManager.GetChannelKeybinding(codeplugIdentifier, channel.ChannelName);
+                
+                if (!string.IsNullOrWhiteSpace(keybinding))
+                {
+                    RegisterChannelHotkey(channel.ChannelName, keybinding);
+                    registeredCount++;
+                }
+            }
+            
+            if (registeredCount > 0)
+            {
+                Console.WriteLine($"Registered {registeredCount} channel hotkey(s)");
+            }
+        }
+
+        /// <summary>
+        /// Registers a hotkey for a specific channel
+        /// </summary>
+        private void RegisterChannelHotkey(string channelName, string keybinding)
+        {
+            if (_globalHotKeyManager == null)
+            {
+                Console.WriteLine($"ERROR: GlobalHotKeyManager is null! Cannot register hotkey for '{channelName}'");
+                return;
+            }
+
+            // Unregister old hotkey if it exists
+            if (_channelHotKeyIds.ContainsKey(channelName))
+            {
+                var oldHotKeyId = _channelHotKeyIds[channelName];
+                _globalHotKeyManager.UnregisterHotKey(oldHotKeyId);
+                _channelHotKeyIds.Remove(channelName);
+                _hotKeyIdToChannelName.Remove(oldHotKeyId);
+            }
+
+            // Parse the keybinding
+            if (!KeybindingParser.TryParseKeybinding(keybinding, out var modifiers, out var key))
+            {
+                Console.WriteLine($"ERROR: Failed to parse keybinding '{keybinding}' for channel '{channelName}'");
+                return;
+            }
+
+            // Register with global hotkey manager
+            var hotKeyId = _globalHotKeyManager.RegisterHotKey(
+                modifiers,
+                key,
+                () => OnChannelHotKeyDown(channelName),
+                () => OnChannelHotKeyUp(channelName)
+            );
+
+            if (hotKeyId != -1)
+            {
+                _channelHotKeyIds[channelName] = hotKeyId;
+                _hotKeyIdToChannelName[hotKeyId] = channelName;
+            }
+            else
+            {
+                Console.WriteLine($"Failed to register hotkey '{keybinding}' for channel '{channelName}'");
+            }
+        }
+
+        /// <summary>
+        /// Unregisters a hotkey for a specific channel
+        /// </summary>
+        public void UnregisterChannelHotkey(string channelName)
+        {
+            if (_channelHotKeyIds.TryGetValue(channelName, out var hotKeyId))
+            {
+                _globalHotKeyManager.UnregisterHotKey(hotKeyId);
+                _channelHotKeyIds.Remove(channelName);
+                _hotKeyIdToChannelName.Remove(hotKeyId);
+            }
+        }
+
+        /// <summary>
+        /// Unregisters all channel hotkeys
+        /// </summary>
+        public void UnregisterAllChannelHotkeys()
+        {
+            var channelNames = new List<string>(_channelHotKeyIds.Keys);
+            foreach (var channelName in channelNames)
+            {
+                UnregisterChannelHotkey(channelName);
+            }
+        }
+
+        /// <summary>
+        /// Called when a channel hotkey is pressed
+        /// </summary>
+        private void OnChannelHotKeyDown(string channelName)
+        {
+            var channel = _allChannels.FirstOrDefault(c => c.ChannelName == channelName);
+            if (channel != null)
+            {
+                _onChannelPttTriggered?.Invoke(channel, true);
+            }
+        }
+
+        /// <summary>
+        /// Called when a channel hotkey is released
+        /// </summary>
+        private void OnChannelHotKeyUp(string channelName)
+        {
+            var channel = _allChannels.FirstOrDefault(c => c.ChannelName == channelName);
+            if (channel != null)
+            {
+                _onChannelPttTriggered?.Invoke(channel, false);
+            }
+        }
+    }
+}
diff --git a/WhackerLinkConsoleV2/ChannelKeybindingManager.cs b/WhackerLinkConsoleV2/ChannelKeybindingManager.cs
new file mode 100644
index 0000000..0971293
--- /dev/null
+++ b/WhackerLinkConsoleV2/ChannelKeybindingManager.cs
@@ -0,0 +1,214 @@
+/*
+* WhackerLink - WhackerLinkConsoleV2
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program.  If not, see <http://www.gnu.org/licenses/>.
+* 
+* Copyright (C) 2024-2025 Caleb, K4PHP
+* Copyright (C) 2025 Firav (firavdev@gmail.com)
+* 
+*/
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Security.Cryptography;
+using System.Text;
+using Newtonsoft.Json;
+
+namespace WhackerLinkConsoleV2
+{
+    /// <summary>
+    /// Manages per-channel PTT keybindings, storing them persistently.
+    /// Bindings are organized by codeplug + channel name for dynamic channel support.
+    /// </summary>
+    public class ChannelKeybindingManager
+    {
+        private const string ChannelKeybindingsFilePath = "ChannelKeybindings.json";
+
+        private Dictionary<string, ChannelKeybindingProfile> _keybindingProfiles = 
+            new Dictionary<string, ChannelKeybindingProfile>();
+
+        /// <summary>
+        /// Represents keybindings for a specific codeplug
+        /// </summary>
+        public class ChannelKeybindingProfile
+        {
+            /// <summary>
+            /// Channel name -> keybinding string mapping (e.g., "MainChannel" -> "Ctrl+T")
+            /// </summary>
+            public Dictionary<string, string> ChannelKeybindings { get; set; } = 
+                new Dictionary<string, string>();
+        }
+
+        /// <summary>
+        /// Loads keybinding profiles from disk
+        /// </summary>
+        public void LoadKeybindings()
+        {
+            if (!File.Exists(ChannelKeybindingsFilePath))
+            {
+                Console.WriteLine("Channel keybindings file not found. Starting with empty configuration.");
+                return;
+            }
+
+            try
+            {
+                var json = File.ReadAllText(ChannelKeybindingsFilePath);
+                var loadedProfiles = JsonConvert.DeserializeObject<Dictionary<string, ChannelKeybindingProfile>>(json);
+
+                if (loadedProfiles != null)
+                {
+                    _keybindingProfiles = loadedProfiles;
+                    Console.WriteLine($"Loaded {_keybindingProfiles.Count} channel keybinding profiles.");
+                }
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"ERROR: Failed to load channel keybindings: {ex.Message}");
+            }
+        }
+
+        /// <summary>
+        /// Saves all keybinding profiles to disk
+        /// </summary>
+        public void SaveKeybindings()
+        {
+            try
+            {
+                var json = JsonConvert.SerializeObject(_keybindingProfiles, Formatting.Indented);
+                File.WriteAllText(ChannelKeybindingsFilePath, json);
+                Console.WriteLine("Channel keybindings saved.");
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"ERROR: Failed to save channel keybindings: {ex.Message}");
+            }
+        }
+
+        /// <summary>
+        /// Gets or creates a keybinding profile for a codeplug
+        /// </summary>
+        private ChannelKeybindingProfile GetOrCreateProfile(string codeplugIdentifier)
+        {
+            if (!_keybindingProfiles.ContainsKey(codeplugIdentifier))
+            {
+                _keybindingProfiles[codeplugIdentifier] = new ChannelKeybindingProfile();
+            }
+
+            return _keybindingProfiles[codeplugIdentifier];
+        }
+
+        /// <summary>
+        /// Sets a keybinding for a specific channel in a codeplug
+        /// </summary>
+        public void SetChannelKeybinding(string codeplugIdentifier, string channelName, string keybinding)
+        {
+            var profile = GetOrCreateProfile(codeplugIdentifier);
+            
+            if (string.IsNullOrWhiteSpace(keybinding))
+            {
+                profile.ChannelKeybindings.Remove(channelName);
+            }
+            else
+            {
+                profile.ChannelKeybindings[channelName] = keybinding;
+            }
+
+            SaveKeybindings();
+            Console.WriteLine($"Set keybinding for {channelName}: {keybinding}");
+        }
+
+        /// <summary>
+        /// Gets the keybinding for a specific channel, returns null if not set
+        /// </summary>
+        public string GetChannelKeybinding(string codeplugIdentifier, string channelName)
+        {
+            if (!_keybindingProfiles.TryGetValue(codeplugIdentifier, out var profile))
+                return null;
+
+            if (profile.ChannelKeybindings.TryGetValue(channelName, out var keybinding))
+                return keybinding;
+
+            return null;
+        }
+
+        /// <summary>
+        /// Gets all channels with keybindings for a codeplug
+        /// </summary>
+        public IEnumerable<string> GetChannelsWithKeybindings(string codeplugIdentifier)
+        {
+            if (_keybindingProfiles.TryGetValue(codeplugIdentifier, out var profile))
+                return profile.ChannelKeybindings.Keys;
+
+            return new List<string>();
+        }
+
+        /// <summary>
+        /// Removes a keybinding for a specific channel
+        /// </summary>
+        public void RemoveChannelKeybinding(string codeplugIdentifier, string channelName)
+        {
+            var profile = GetOrCreateProfile(codeplugIdentifier);
+            if (profile.ChannelKeybindings.Remove(channelName))
+            {
+                SaveKeybindings();
+                Console.WriteLine($"Removed keybinding for {channelName}");
+            }
+        }
+
+        /// <summary>
+        /// Clears all keybindings for a codeplug profile
+        /// </summary>
+        public void ClearProfile(string codeplugIdentifier)
+        {
+            if (_keybindingProfiles.Remove(codeplugIdentifier))
+            {
+                SaveKeybindings();
+                Console.WriteLine($"Cleared all keybindings for profile: {codeplugIdentifier}");
+            }
+        }
+
+        /// <summary>
+        /// Gets all keybinding profiles
+        /// </summary>
+        public Dictionary<string, ChannelKeybindingProfile> GetAllProfiles()
+        {
+            return new Dictionary<string, ChannelKeybindingProfile>(_keybindingProfiles);
+        }
+
+        /// <summary>
+        /// Generates a unique identifier for a codeplug (using deterministic file path hash)
+        /// </summary>
+        public static string GenerateCodeplugIdentifier(string codeplugFilePath)
+        {
+            if (string.IsNullOrWhiteSpace(codeplugFilePath))
+                return "default";
+
+            // Use a combination of filename and deterministic path hash
+            var fileName = Path.GetFileNameWithoutExtension(codeplugFilePath);
+            
+            // Use SHA256 for deterministic hashing (same path always produces same hash)
+            using (var sha256 = SHA256.Create())
+            {
+                var pathBytes = Encoding.UTF8.GetBytes(codeplugFilePath.ToLowerInvariant());
+                var hashBytes = sha256.ComputeHash(pathBytes);
+                
+                // Take first 4 bytes and convert to hex (8 characters)
+                var pathHash = BitConverter.ToString(hashBytes, 0, 4).Replace("-", "");
+                
+                return $"{fileName}_{pathHash}";
+            }
+        }
+    }
+}
diff --git a/WhackerLinkConsoleV2/GlobalHotKeyManager.cs b/WhackerLinkConsoleV2/GlobalHotKeyManager.cs
new file mode 100644
index 0000000..9fef052
--- /dev/null
+++ b/WhackerLinkConsoleV2/GlobalHotKeyManager.cs
@@ -0,0 +1,417 @@
+/*
+* WhackerLink - WhackerLinkConsoleV2
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program.  If not, see <http://www.gnu.org/licenses/>.
+* 
+* Copyright (C) 2024-2025 Caleb, K4PHP
+* Copyright (C) 2025 Firav (firavdev@gmail.com)
+* 
+*/
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+using System.Windows.Interop;
+using System.Windows;
+using System.Windows.Input;
+
+namespace WhackerLinkConsoleV2
+{
+    /// <summary>
+    /// Represents arguments for hotkey events
+    /// </summary>
+    public class HotKeyEventArgs : EventArgs
+    {
+        public int HotKeyId { get; set; }
+        public Key Key { get; set; }
+        public ModifierKeys Modifiers { get; set; }
+    }
+
+    /// <summary>
+    /// Manages global system hotkeys using Windows API
+    /// </summary>
+    public class GlobalHotKeyManager : IDisposable
+    {
+        // Windows API P/Invoke declarations
+        [DllImport("user32.dll")]
+        private static extern bool RegisterHotKey(IntPtr hWnd, int id, uint fsModifiers, uint vk);
+
+        [DllImport("user32.dll")]
+        private static extern bool UnregisterHotKey(IntPtr hWnd, int id);
+
+        [DllImport("user32.dll")]
+        private static extern uint MapVirtualKey(uint uCode, uint uMapType);
+
+        [DllImport("kernel32.dll")]
+        private static extern uint GetLastError();
+
+        [DllImport("user32.dll")]
+        private static extern short GetAsyncKeyState(int vKey);
+
+        // Modifier key constants
+        private const uint MOD_NONE = 0x0000;
+        private const uint MOD_ALT = 0x0001;
+        private const uint MOD_CONTROL = 0x0002;
+        private const uint MOD_SHIFT = 0x0004;
+        private const uint MOD_WIN = 0x0008;
+
+        // Message constants
+        private const int WM_HOTKEY = 0x0312;
+
+        // Virtual key codes for modifier keys
+        private const int VK_CONTROL = 0x11;
+        private const int VK_SHIFT = 0x10;
+        private const int VK_MENU = 0x12; // Alt key
+
+        private Window _window;
+        private IntPtr _windowHandle;
+        private HwndSource _hwndSource;
+        private Dictionary<int, HotKeyInfo> _registeredHotKeys = new Dictionary<int, HotKeyInfo>();
+        private Dictionary<int, bool> _hotKeyStates = new Dictionary<int, bool>(); // Track if hotkey is currently pressed
+        private int _nextHotKeyId = 1;
+        private System.Timers.Timer _keyStateTimer;
+
+        public event EventHandler<HotKeyEventArgs> HotKeyPressed;
+        public event EventHandler<HotKeyEventArgs> HotKeyReleased;
+
+        /// <summary>
+        /// Internal class to track hotkey information
+        /// </summary>
+        private class HotKeyInfo
+        {
+            public int Id { get; set; }
+            public Key Key { get; set; }
+            public ModifierKeys Modifiers { get; set; }
+            public Action OnKeyDown { get; set; }
+            public Action OnKeyUp { get; set; }
+        }
+
+        /// <summary>
+        /// Initializes the global hotkey manager for the specified window
+        /// </summary>
+        public void Initialize(Window window)
+        {
+            _window = window;
+            _windowHandle = new WindowInteropHelper(window).Handle;
+            
+            if (_windowHandle == IntPtr.Zero)
+            {
+                throw new InvalidOperationException("Window handle is invalid. Ensure the window is fully initialized.");
+            }
+
+            _hwndSource = HwndSource.FromHwnd(_windowHandle);
+            if (_hwndSource != null)
+            {
+                _hwndSource.AddHook(HwndHook);
+            }
+
+            // Start a timer to poll key states for detecting key releases
+            _keyStateTimer = new System.Timers.Timer(50); // Poll every 50ms
+            _keyStateTimer.Elapsed += CheckKeyStates;
+            _keyStateTimer.AutoReset = true;
+            _keyStateTimer.Start();
+        }
+
+        /// <summary>
+        /// Registers a global hotkey
+        /// </summary>
+        /// <returns>Returns the hotkey ID if successful, -1 if failed</returns>
+        public int RegisterHotKey(ModifierKeys modifier, Key key, Action onKeyDown = null, Action onKeyUp = null)
+        {
+            if (_windowHandle == IntPtr.Zero)
+            {
+                Console.WriteLine($"ERROR: GlobalHotKeyManager not initialized. Call Initialize() first.");
+                return -1;
+            }
+
+            // Single-key hotkeys without modifiers are not recommended and may be rejected by Windows
+            if (modifier == ModifierKeys.None)
+            {
+                Console.WriteLine($"WARNING: Single-key hotkey without modifiers ({key}) may not work reliably or may be rejected by Windows.");
+                Console.WriteLine($"         It's recommended to use at least one modifier key (e.g., Ctrl+{key}).");
+            }
+
+            int hotKeyId = _nextHotKeyId++;
+            uint modifierFlags = ConvertModifierKeys(modifier);
+            uint vkCode = (uint)KeyInterop.VirtualKeyFromKey(key);
+
+            if (vkCode == 0)
+            {
+                Console.WriteLine($"ERROR: Could not convert key {key} to virtual key code.");
+                return -1;
+            }
+
+            if (RegisterHotKey(_windowHandle, hotKeyId, modifierFlags, vkCode))
+            {
+                var hotKeyInfo = new HotKeyInfo
+                {
+                    Id = hotKeyId,
+                    Key = key,
+                    Modifiers = modifier,
+                    OnKeyDown = onKeyDown,
+                    OnKeyUp = onKeyUp
+                };
+
+                _registeredHotKeys[hotKeyId] = hotKeyInfo;
+                
+                return hotKeyId;
+            }
+            else
+            {
+                uint error = GetLastError();
+                string modifierStr = modifier == ModifierKeys.None ? "(no modifiers)" : modifier.ToString();
+                Console.WriteLine($"ERROR: Failed to register hotkey {modifierStr}+{key}. Error code: {error}");
+                
+                // Common error codes
+                if (error == 1409) // ERROR_HOTKEY_ALREADY_REGISTERED
+                {
+                    Console.WriteLine($"       This hotkey is already registered by another application.");
+                }
+                
+                return -1;
+            }
+        }
+
+        /// <summary>
+        /// Unregisters a global hotkey by ID
+        /// </summary>
+        public bool UnregisterHotKey(int hotKeyId)
+        {
+            if (!_registeredHotKeys.ContainsKey(hotKeyId))
+            {
+                Console.WriteLine($"WARNING: Hotkey ID {hotKeyId} not found in registered hotkeys.");
+                return false;
+            }
+
+            if (UnregisterHotKey(_windowHandle, hotKeyId))
+            {
+                _registeredHotKeys.Remove(hotKeyId);
+                return true;
+            }
+            else
+            {
+                uint error = GetLastError();
+                Console.WriteLine($"ERROR: Failed to unregister hotkey ID {hotKeyId}. Error code: {error}");
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// Unregisters all registered hotkeys
+        /// </summary>
+        public void UnregisterAllHotKeys()
+        {
+            var hotKeyIds = new List<int>(_registeredHotKeys.Keys);
+            foreach (var id in hotKeyIds)
+            {
+                UnregisterHotKey(id);
+            }
+        }
+
+        /// <summary>
+        /// Gets information about a registered hotkey
+        /// </summary>
+        public bool GetHotKeyInfo(int hotKeyId, out ModifierKeys modifier, out Key key)
+        {
+            modifier = ModifierKeys.None;
+            key = Key.None;
+
+            if (_registeredHotKeys.TryGetValue(hotKeyId, out var hotKeyInfo))
+            {
+                modifier = hotKeyInfo.Modifiers;
+                key = hotKeyInfo.Key;
+                return true;
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Gets the list of all registered hotkey IDs
+        /// </summary>
+        public IEnumerable<int> GetRegisteredHotKeyIds()
+        {
+            return new List<int>(_registeredHotKeys.Keys);
+        }
+
+        /// <summary>
+        /// Converts WPF ModifierKeys to Windows API modifier flags
+        /// </summary>
+        private uint ConvertModifierKeys(ModifierKeys modifiers)
+        {
+            uint result = MOD_NONE;
+
+            if ((modifiers & ModifierKeys.Alt) == ModifierKeys.Alt)
+                result |= MOD_ALT;
+            if ((modifiers & ModifierKeys.Control) == ModifierKeys.Control)
+                result |= MOD_CONTROL;
+            if ((modifiers & ModifierKeys.Shift) == ModifierKeys.Shift)
+                result |= MOD_SHIFT;
+            if ((modifiers & ModifierKeys.Windows) == ModifierKeys.Windows)
+                result |= MOD_WIN;
+
+            return result;
+        }
+
+        /// <summary>
+        /// Window message hook for processing hotkey messages
+        /// </summary>
+        private IntPtr HwndHook(IntPtr hwnd, int msg, IntPtr wParam, IntPtr lParam, ref bool handled)
+        {
+            if (msg == WM_HOTKEY)
+            {
+                int hotKeyId = wParam.ToInt32();
+
+                if (_registeredHotKeys.TryGetValue(hotKeyId, out var hotKeyInfo))
+                {
+                    // Check if this hotkey is already pressed (to prevent repeated triggers)
+                    bool wasAlreadyPressed = _hotKeyStates.TryGetValue(hotKeyId, out bool isPressed) && isPressed;
+
+                    if (!wasAlreadyPressed)
+                    {
+                        // Only trigger on first press, not repeated WM_HOTKEY messages
+                        var args = new HotKeyEventArgs
+                        {
+                            HotKeyId = hotKeyId,
+                            Key = hotKeyInfo.Key,
+                            Modifiers = hotKeyInfo.Modifiers
+                        };
+
+                        // Fire the pressed event
+                        HotKeyPressed?.Invoke(this, args);
+
+                        // Call the on-key-down callback if registered
+                        hotKeyInfo.OnKeyDown?.Invoke();
+
+                        // Mark this hotkey as pressed
+                        _hotKeyStates[hotKeyId] = true;
+                    }
+
+                    handled = true;
+                }
+            }
+
+            return IntPtr.Zero;
+        }
+
+        /// <summary>
+        /// Checks if keys are still pressed (polling for key release detection)
+        /// </summary>
+        private void CheckKeyStates(object sender, System.Timers.ElapsedEventArgs e)
+        {
+            var hotKeysToRelease = new List<int>();
+
+            foreach (var kvp in _registeredHotKeys)
+            {
+                int hotKeyId = kvp.Key;
+                var hotKeyInfo = kvp.Value;
+
+                // Check if this hotkey is currently marked as pressed
+                if (_hotKeyStates.TryGetValue(hotKeyId, out bool isPressed) && isPressed)
+                {
+                    // Check if the key combination is still held
+                    if (!IsKeyCombinationPressed(hotKeyInfo.Modifiers, hotKeyInfo.Key))
+                    {
+                        hotKeysToRelease.Add(hotKeyId);
+                    }
+                }
+            }
+
+            // Release keys that are no longer pressed
+            foreach (var hotKeyId in hotKeysToRelease)
+            {
+                _hotKeyStates[hotKeyId] = false;
+
+                if (_registeredHotKeys.TryGetValue(hotKeyId, out var hotKeyInfo))
+                {
+                    // Call the on-key-up callback if registered
+                    _window?.Dispatcher.Invoke(() =>
+                    {
+                        hotKeyInfo.OnKeyUp?.Invoke();
+                    });
+
+                    // Fire the released event
+                    _window?.Dispatcher.Invoke(() =>
+                    {
+                        var args = new HotKeyEventArgs
+                        {
+                            HotKeyId = hotKeyId,
+                            Key = hotKeyInfo.Key,
+                            Modifiers = hotKeyInfo.Modifiers
+                        };
+                        HotKeyReleased?.Invoke(this, args);
+                    });
+                }
+            }
+        }
+
+        /// <summary>
+        /// Checks if a key combination is currently pressed
+        /// </summary>
+        private bool IsKeyCombinationPressed(ModifierKeys modifiers, Key key)
+        {
+            // Check modifiers
+            if ((modifiers & ModifierKeys.Control) == ModifierKeys.Control)
+            {
+                if ((GetAsyncKeyState(VK_CONTROL) & 0x8000) == 0)
+                    return false;
+            }
+
+            if ((modifiers & ModifierKeys.Shift) == ModifierKeys.Shift)
+            {
+                if ((GetAsyncKeyState(VK_SHIFT) & 0x8000) == 0)
+                    return false;
+            }
+
+            if ((modifiers & ModifierKeys.Alt) == ModifierKeys.Alt)
+            {
+                if ((GetAsyncKeyState(VK_MENU) & 0x8000) == 0)
+                    return false;
+            }
+
+            // Check the main key
+            int vkCode = KeyInterop.VirtualKeyFromKey(key);
+            if ((GetAsyncKeyState(vkCode) & 0x8000) == 0)
+                return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Cleanup resources
+        /// </summary>
+        public void Dispose()
+        {
+            // Stop the key state timer
+            if (_keyStateTimer != null)
+            {
+                _keyStateTimer.Stop();
+                _keyStateTimer.Dispose();
+                _keyStateTimer = null;
+            }
+
+            UnregisterAllHotKeys();
+
+            if (_hwndSource != null)
+            {
+                _hwndSource.RemoveHook(HwndHook);
+                _hwndSource.Dispose();
+            }
+
+            _window = null;
+            _windowHandle = IntPtr.Zero;
+            _hwndSource = null;
+        }
+    }
+}
diff --git a/WhackerLinkConsoleV2/KeybindingParser.cs b/WhackerLinkConsoleV2/KeybindingParser.cs
new file mode 100644
index 0000000..a7a3074
--- /dev/null
+++ b/WhackerLinkConsoleV2/KeybindingParser.cs
@@ -0,0 +1,147 @@
+/*
+* WhackerLink - WhackerLinkConsoleV2
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program.  If not, see <http://www.gnu.org/licenses/>.
+* 
+* Copyright (C) 2024-2025 Caleb, K4PHP
+* Copyright (C) 2025 Firav (firavdev@gmail.com)
+* 
+*/
+
+using System;
+using System.Windows.Input;
+
+namespace WhackerLinkConsoleV2
+{
+    /// <summary>
+    /// Helper class to parse and convert keybinding strings.
+    /// Supports both single-key (e.g., "T", "F1") and multi-key (e.g., "Ctrl+T", "Ctrl+Alt+P")
+    /// </summary>
+    public static class KeybindingParser
+    {
+    /// <summary>
+    /// Parses a keybinding string like "Ctrl+Alt+P" into ModifierKeys and Key
+    /// </summary>
+    /// <returns>Returns true if parsing was successful</returns>
+    public static bool TryParseKeybinding(string keybindingString, out ModifierKeys modifiers, out Key key)
+    {
+        modifiers = ModifierKeys.None;
+        key = Key.None;
+
+        if (string.IsNullOrWhiteSpace(keybindingString))
+        {
+            Console.WriteLine("ERROR: Keybinding string is null or empty");
+            return false;
+        }
+
+        try
+        {
+            var parts = keybindingString.Split('+');
+
+            if (parts.Length == 0)
+            {
+                Console.WriteLine($"ERROR: Invalid keybinding format: '{keybindingString}'");
+                return false;
+            }
+
+            // Handle single-key keybindings (e.g., "T", "P", "F1")
+            if (parts.Length == 1)
+            {
+                string keyString = parts[0].Trim();
+                if (!Enum.TryParse<Key>(keyString, true, out key))
+                {
+                    Console.WriteLine($"ERROR: Unknown key: '{keyString}'");
+                    return false;
+                }
+
+                if (key == Key.None)
+                {
+                    Console.WriteLine($"ERROR: Key cannot be None");
+                    return false;
+                }
+
+                return true;
+            }
+
+            // Handle multi-key keybindings (e.g., "Ctrl+T", "Ctrl+Alt+P")
+            // Parse modifiers from all but the last part
+            for (int i = 0; i < parts.Length - 1; i++)
+            {
+                string part = parts[i].Trim().ToLower();
+
+                switch (part)
+                {
+                    case "ctrl":
+                    case "control":
+                        modifiers |= ModifierKeys.Control;
+                        break;
+                    case "alt":
+                        modifiers |= ModifierKeys.Alt;
+                        break;
+                    case "shift":
+                        modifiers |= ModifierKeys.Shift;
+                        break;
+                    case "win":
+                    case "windows":
+                        modifiers |= ModifierKeys.Windows;
+                        break;
+                    default:
+                        Console.WriteLine($"ERROR: Unknown modifier key: '{part}'");
+                        return false;
+                }
+            }
+
+            // Parse the main key from the last part
+            string keyStr = parts[parts.Length - 1].Trim();
+            if (!Enum.TryParse<Key>(keyStr, true, out key))
+            {
+                Console.WriteLine($"ERROR: Unknown key: '{keyStr}'");
+                return false;
+            }
+
+            if (key == Key.None)
+            {
+                Console.WriteLine($"ERROR: Key cannot be None");
+                return false;
+            }
+
+            return true;
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine($"ERROR: Exception parsing keybinding '{keybindingString}': {ex.Message}");
+            return false;
+        }
+    }        /// <summary>
+        /// Converts ModifierKeys and Key back to a keybinding string
+        /// </summary>
+        public static string KeybindingToString(ModifierKeys modifiers, Key key)
+        {
+            var result = "";
+
+            if ((modifiers & ModifierKeys.Control) == ModifierKeys.Control)
+                result += "Ctrl+";
+            if ((modifiers & ModifierKeys.Alt) == ModifierKeys.Alt)
+                result += "Alt+";
+            if ((modifiers & ModifierKeys.Shift) == ModifierKeys.Shift)
+                result += "Shift+";
+            if ((modifiers & ModifierKeys.Windows) == ModifierKeys.Windows)
+                result += "Win+";
+
+            result += key.ToString();
+
+            return result;
+        }
+    }
+}

From cbac16810dba18183e35f6fcfd6878cd8d1552b5 Mon Sep 17 00:00:00 2001
From: Firav <firavv@gmail.com>
Date: Tue, 11 Nov 2025 12:42:16 -0500
Subject: [PATCH 03/13] add UI for managing keybinds

---
 .../KeybindingConfigWindow.xaml               |  71 +++++
 .../KeybindingConfigWindow.xaml.cs            | 265 ++++++++++++++++++
 2 files changed, 336 insertions(+)
 create mode 100644 WhackerLinkConsoleV2/KeybindingConfigWindow.xaml
 create mode 100644 WhackerLinkConsoleV2/KeybindingConfigWindow.xaml.cs

diff --git a/WhackerLinkConsoleV2/KeybindingConfigWindow.xaml b/WhackerLinkConsoleV2/KeybindingConfigWindow.xaml
new file mode 100644
index 0000000..8a896b6
--- /dev/null
+++ b/WhackerLinkConsoleV2/KeybindingConfigWindow.xaml
@@ -0,0 +1,71 @@
+<Window x:Class="WhackerLinkConsoleV2.KeybindingConfigWindow"
+        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+        Title="PTT Keybinding Configuration" Height="600" Width="800"
+        WindowStartupLocation="CenterScreen">
+    <Grid Margin="10">
+        <Grid.RowDefinitions>
+            <RowDefinition Height="Auto"/>
+            <RowDefinition Height="Auto"/>
+            <RowDefinition Height="*"/>
+            <RowDefinition Height="Auto"/>
+        </Grid.RowDefinitions>
+
+        <!-- Global PTT Section -->
+        <TextBlock Text="Global PTT Keybind" FontWeight="Bold" Margin="0,0,0,5" Grid.Row="0"/>
+        <Grid Grid.Row="1" Margin="0,5,0,15">
+            <Grid.ColumnDefinitions>
+                <ColumnDefinition Width="*"/>
+                <ColumnDefinition Width="Auto"/>
+                <ColumnDefinition Width="Auto"/>
+            </Grid.ColumnDefinitions>
+            
+            <TextBox x:Name="GlobalPttKeybindDisplay" 
+                     Text="Ctrl+T" 
+                     IsReadOnly="True" 
+                     VerticalContentAlignment="Center"
+                     Padding="5"
+                     Grid.Column="0"
+                     Margin="0,0,10,0"/>
+            
+            <Button x:Name="RecordGlobalPttButton" 
+                    Click="RecordGlobalPtt_Click" 
+                    Content="Record" 
+                    Width="80" 
+                    Margin="0,0,10,0"
+                    Grid.Column="1"/>
+            
+            <Button x:Name="ClearGlobalPttButton" 
+                    Click="ClearGlobalPtt_Click" 
+                    Content="Clear" 
+                    Width="80"
+                    Grid.Column="2"/>
+        </Grid>
+
+        <!-- Per-Channel Section -->
+        <TextBlock Text="Per-Channel PTT Keybindings" FontWeight="Bold" Grid.Row="2" Margin="0,0,0,5"/>
+        <ScrollViewer Grid.Row="2" Margin="0,25,0,0">
+            <StackPanel>
+                <TextBlock x:Name="CodeplugIdentifierText" 
+                           Text="No codeplug loaded" 
+                           FontSize="10" 
+                           Foreground="Gray" 
+                           Margin="0,0,0,10"/>
+                <StackPanel x:Name="ChannelKeybindingsPanel"/>
+            </StackPanel>
+        </ScrollViewer>
+
+        <!-- Footer Buttons -->
+        <StackPanel Orientation="Horizontal" HorizontalAlignment="Right" Grid.Row="3" Margin="0,20,0,0">
+            <Button x:Name="ApplyButton" 
+                    Click="Apply_Click" 
+                    Content="Apply" 
+                    Width="100" 
+                    Margin="0,0,10,0"/>
+            <Button x:Name="CloseButton" 
+                    Click="Close_Click" 
+                    Content="Close" 
+                    Width="100"/>
+        </StackPanel>
+    </Grid>
+</Window>
diff --git a/WhackerLinkConsoleV2/KeybindingConfigWindow.xaml.cs b/WhackerLinkConsoleV2/KeybindingConfigWindow.xaml.cs
new file mode 100644
index 0000000..1afb635
--- /dev/null
+++ b/WhackerLinkConsoleV2/KeybindingConfigWindow.xaml.cs
@@ -0,0 +1,265 @@
+/*
+* WhackerLink - WhackerLinkConsoleV2
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program.  If not, see <http://www.gnu.org/licenses/>.
+* 
+* Copyright (C) 2024-2025 Caleb, K4PHP
+* Copyright (C) 2025 Firav (firavdev@gmail.com)
+* 
+*/
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Input;
+using WhackerLinkLib.Models.Radio;
+
+namespace WhackerLinkConsoleV2
+{
+    public partial class KeybindingConfigWindow : Window
+    {
+        private SettingsManager _settingsManager;
+        private ChannelKeybindingManager _channelKeybindingManager;
+        private Codeplug _codeplug;
+        private string _codeplugIdentifier;
+
+        private bool _recordingGlobalPtt = false;
+        private Dictionary<string, TextBox> _channelKeybindingControls = new Dictionary<string, TextBox>();
+
+        public KeybindingConfigWindow(SettingsManager settingsManager, ChannelKeybindingManager channelKeybindingManager, Codeplug codeplug, string codeplugFilePath)
+        {
+            InitializeComponent();
+            _settingsManager = settingsManager;
+            _channelKeybindingManager = channelKeybindingManager;
+            _codeplug = codeplug;
+            _codeplugIdentifier = ChannelKeybindingManager.GenerateCodeplugIdentifier(codeplugFilePath);
+
+            LoadSettings();
+            GenerateChannelControls();
+        }
+
+        private void LoadSettings()
+        {
+            // Load global keybinding
+            GlobalPttKeybindDisplay.Text = _settingsManager.GlobalPttKeybind;
+
+            // Load codeplug identifier
+            CodeplugIdentifierText.Text = _codeplugIdentifier;
+        }
+
+        private void GenerateChannelControls()
+        {
+            ChannelKeybindingsPanel.Children.Clear();
+            _channelKeybindingControls.Clear();
+
+            if (_codeplug == null || _codeplug.Zones == null || _codeplug.Zones.Count == 0)
+            {
+                var noChannelsText = new TextBlock
+                {
+                    Text = "No channels available",
+                    Foreground = System.Windows.Media.Brushes.Gray,
+                    FontSize = 11,
+                    Margin = new Thickness(0, 10, 0, 0)
+                };
+                ChannelKeybindingsPanel.Children.Add(noChannelsText);
+                return;
+            }
+
+            var allChannels = _codeplug.Zones.SelectMany(z => z.Channels).Distinct().OrderBy(c => c.Name).ToList();
+
+            if (allChannels.Count == 0)
+            {
+                var noChannelsText = new TextBlock
+                {
+                    Text = "No channels in codeplug",
+                    Foreground = System.Windows.Media.Brushes.Gray,
+                    FontSize = 11,
+                    Margin = new Thickness(0, 10, 0, 0)
+                };
+                ChannelKeybindingsPanel.Children.Add(noChannelsText);
+                return;
+            }
+
+            foreach (var channel in allChannels)
+            {
+                var existingKeybind = _channelKeybindingManager.GetChannelKeybinding(_codeplugIdentifier, channel.Name) ?? "";
+
+                var grid = new Grid
+                {
+                    Margin = new Thickness(0, 0, 0, 10)
+                };
+                grid.ColumnDefinitions.Add(new ColumnDefinition { Width = new GridLength(150) });
+                grid.ColumnDefinitions.Add(new ColumnDefinition { Width = new GridLength(1, GridUnitType.Star) });
+                grid.ColumnDefinitions.Add(new ColumnDefinition { Width = GridLength.Auto });
+
+                // Channel name
+                var channelNameText = new TextBlock
+                {
+                    Text = channel.Name,
+                    VerticalAlignment = VerticalAlignment.Center,
+                    Margin = new Thickness(0, 0, 10, 0)
+                };
+                Grid.SetColumn(channelNameText, 0);
+                grid.Children.Add(channelNameText);
+
+                // Keybinding textbox
+                var keybindTextBox = new TextBox
+                {
+                    Text = existingKeybind,
+                    IsReadOnly = true,
+                    VerticalContentAlignment = VerticalAlignment.Center,
+                    Padding = new Thickness(5),
+                    Margin = new Thickness(0, 0, 10, 0)
+                };
+                Grid.SetColumn(keybindTextBox, 1);
+                grid.Children.Add(keybindTextBox);
+
+                _channelKeybindingControls[channel.Name] = keybindTextBox;
+
+                // Record button
+                var recordButton = new Button
+                {
+                    Content = "Record",
+                    Width = 80,
+                    Tag = channel.Name
+                };
+                recordButton.Click += (s, e) => RecordChannelKeybind_Click(channel.Name);
+                Grid.SetColumn(recordButton, 2);
+                grid.Children.Add(recordButton);
+
+                ChannelKeybindingsPanel.Children.Add(grid);
+            }
+        }
+
+        private void RecordGlobalPtt_Click(object sender, RoutedEventArgs e)
+        {
+            _recordingGlobalPtt = true;
+            RecordGlobalPttButton.Content = "Press keys...";
+            RecordGlobalPttButton.IsEnabled = false;
+            Focus();
+        }
+
+        private void RecordChannelKeybind_Click(string channelName)
+        {
+            if (!_channelKeybindingControls.TryGetValue(channelName, out var textBox))
+                return;
+
+            var recordingTag = $"recording_{channelName}";
+            Tag = recordingTag;
+            textBox.Text = "Press keys...";
+            Focus();
+        }
+
+        private void ClearGlobalPtt_Click(object sender, RoutedEventArgs e)
+        {
+            GlobalPttKeybindDisplay.Text = "";
+        }
+
+        protected override void OnPreviewKeyDown(KeyEventArgs e)
+        {
+            // Get current modifiers
+            var modifiers = Keyboard.Modifiers;
+            var key = e.Key;
+
+            // Don't record if only a modifier key is pressed (wait for the actual key)
+            if (key == Key.LeftCtrl || key == Key.RightCtrl ||
+                key == Key.LeftShift || key == Key.RightShift ||
+                key == Key.LeftAlt || key == Key.RightAlt ||
+                key == Key.LWin || key == Key.RWin ||
+                key == Key.System)
+            {
+                e.Handled = true;
+                return;
+            }
+
+            // Handle global PTT recording
+            if (_recordingGlobalPtt)
+            {
+                var keybinding = KeybindingParser.KeybindingToString(modifiers, key);
+                GlobalPttKeybindDisplay.Text = keybinding;
+                
+                _recordingGlobalPtt = false;
+                RecordGlobalPttButton.Content = "Record";
+                RecordGlobalPttButton.IsEnabled = true;
+                
+                e.Handled = true;
+                return;
+            }
+
+            // Handle channel-specific keybind recording
+            if (Tag is string tag && tag.StartsWith("recording_"))
+            {
+                var channelName = tag.Substring("recording_".Length);
+                if (_channelKeybindingControls.TryGetValue(channelName, out var textBox))
+                {
+                    var keybinding = KeybindingParser.KeybindingToString(modifiers, key);
+                    textBox.Text = keybinding;
+                    Tag = null;
+                }
+                e.Handled = true;
+                return;
+            }
+
+            base.OnPreviewKeyDown(e);
+        }
+
+        private void Apply_Click(object sender, RoutedEventArgs e)
+        {
+            // Validate and save global keybinding
+            if (!string.IsNullOrWhiteSpace(GlobalPttKeybindDisplay.Text))
+            {
+                if (!KeybindingParser.TryParseKeybinding(GlobalPttKeybindDisplay.Text, out _, out _))
+                {
+                    MessageBox.Show("Invalid Global PTT keybinding format.", "Validation Error", MessageBoxButton.OK, MessageBoxImage.Warning);
+                    return;
+                }
+                _settingsManager.GlobalPttKeybind = GlobalPttKeybindDisplay.Text;
+            }
+
+            _settingsManager.SaveSettings();
+
+            // Validate and save per-channel keybindings
+            foreach (var kvp in _channelKeybindingControls)
+            {
+                var channelName = kvp.Key;
+                var textBox = kvp.Value;
+                var keybinding = textBox.Text;
+
+                if (string.IsNullOrWhiteSpace(keybinding))
+                {
+                    _channelKeybindingManager.RemoveChannelKeybinding(_codeplugIdentifier, channelName);
+                }
+                else
+                {
+                    if (!KeybindingParser.TryParseKeybinding(keybinding, out _, out _))
+                    {
+                        MessageBox.Show($"Invalid keybinding for channel '{channelName}': {keybinding}", "Validation Error", MessageBoxButton.OK, MessageBoxImage.Warning);
+                        return;
+                    }
+                    _channelKeybindingManager.SetChannelKeybinding(_codeplugIdentifier, channelName, keybinding);
+                }
+            }
+
+            MessageBox.Show("Keybindings saved successfully! Restart the application or reload the codeplug to apply changes.", "Success", MessageBoxButton.OK, MessageBoxImage.Information);
+            Close();
+        }
+
+        private void Close_Click(object sender, RoutedEventArgs e)
+        {
+            Close();
+        }
+    }
+}

From 9d191b11467c966bca89721d281d3d402f96cca9 Mon Sep 17 00:00:00 2001
From: Firav <firavv@gmail.com>
Date: Tue, 11 Nov 2025 12:43:44 -0500
Subject: [PATCH 04/13] fix debug console showing on release build and add
 commandline arg for manually triggering debug console

---
 WhackerLinkConsoleV2/MainWindow.xaml.cs | 4648 ++++++++++++-----------
 1 file changed, 2330 insertions(+), 2318 deletions(-)

diff --git a/WhackerLinkConsoleV2/MainWindow.xaml.cs b/WhackerLinkConsoleV2/MainWindow.xaml.cs
index d9098ad..a4c1447 100644
--- a/WhackerLinkConsoleV2/MainWindow.xaml.cs
+++ b/WhackerLinkConsoleV2/MainWindow.xaml.cs
@@ -1,2318 +1,2330 @@
-/*
-* WhackerLink - WhackerLinkConsoleV2
-*
-* This program is free software: you can redistribute it and/or modify
-* it under the terms of the GNU General Public License as published by
-* the Free Software Foundation, either version 3 of the License, or
-* (at your option) any later version.
-*
-* This program is distributed in the hope that it will be useful,
-* but WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-* GNU General Public License for more details.
-*
-* You should have received a copy of the GNU General Public License
-* along with this program.  If not, see <http://www.gnu.org/licenses/>.
-* 
-* Copyright (C) 2024-2025 Caleb, K4PHP
-* Copyright (C) 2025 J. Dean
-* 
-*/
-
-using Microsoft.Win32;
-using System;
-using System.Timers;
-using System.IO;
-using System.Windows;
-using System.Windows.Controls;
-using System.Windows.Input;
-using WhackerLinkLib.Models.Radio;
-using YamlDotNet.Serialization;
-using YamlDotNet.Serialization.NamingConventions;
-using WhackerLinkConsoleV2.Controls;
-using WebSocketManager = WhackerLinkLib.Managers.WebSocketManager;
-using System.Windows.Media;
-using WhackerLinkLib.Utils;
-using WhackerLinkLib.Models;
-using System.Net;
-using NAudio.Wave;
-using WhackerLinkLib.Interfaces;
-using WhackerLinkLib.Models.IOSP;
-using fnecore.P25;
-using fnecore;
-using Microsoft.VisualBasic;
-using System.Text;
-using Constants = fnecore.Constants;
-using System.Security.Cryptography;
-using fnecore.P25.LC.TSBK;
-using WebSocketSharp;
-using NWaves.Signals;
-using static WhackerLinkConsoleV2.P25Crypto;
-using static WhackerLinkLib.Models.Radio.Codeplug;
-
-namespace WhackerLinkConsoleV2
-{
-    public partial class MainWindow : Window
-    {
-        public Codeplug Codeplug { get; set; }
-        private bool isEditMode = false;
-
-        private bool globalPttState = false;
-
-        private UIElement _draggedElement;
-        private Point _startPoint;
-        private double _offsetX;
-        private double _offsetY;
-        private bool _isDragging;
-
-        private SettingsManager _settingsManager = new SettingsManager();
-        private SelectedChannelsManager _selectedChannelsManager;
-        private FlashingBackgroundManager _flashingManager;
-        private WaveFilePlaybackManager _emergencyAlertPlayback;
-        private WebSocketManager _webSocketManager = new WebSocketManager();
-
-        private ChannelBox playbackChannelBox;
-
-        CallHistoryWindow callHistoryWindow = new CallHistoryWindow();
-
-        public static string PLAYBACKTG = "LOCPLAYBACK";
-        public static string PLAYBACKSYS = "LOCPLAYBACKSYS";
-        public static string PLAYBACKCHNAME = "PLAYBACK";
-
-        private readonly WaveInEvent _waveIn;
-        private readonly AudioManager _audioManager;
-
-        private static System.Timers.Timer _channelHoldTimer;
-
-        private Dictionary<string, SlotStatus> systemStatuses = new Dictionary<string, SlotStatus>();
-        private FneSystemManager _fneSystemManager = new FneSystemManager();
-
-        private bool cryptodev = true;
-
-        private static HashSet<uint> usedRids = new HashSet<uint>();
-
-        List<Tuple<uint, uint>> fneAffs = new List<Tuple<uint, uint>>();
-
-        public MainWindow()
-        {
-#if !DEBUG
-            ConsoleNative.ShowConsole();
-#endif
-            InitializeComponent();
-            _settingsManager.LoadSettings();
-            _selectedChannelsManager = new SelectedChannelsManager();
-            _flashingManager = new FlashingBackgroundManager(null, ChannelsCanvas, null, this);
-            _emergencyAlertPlayback = new WaveFilePlaybackManager(System.IO.Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "emergency.wav"));
-
-            _channelHoldTimer = new System.Timers.Timer(10000);
-            _channelHoldTimer.Elapsed += OnHoldTimerElapsed;
-            _channelHoldTimer.AutoReset = true;
-            _channelHoldTimer.Enabled = true;
-
-            _waveIn = new WaveInEvent
-            {
-                WaveFormat = new WaveFormat(8000, 16, 1)
-            };
-            _waveIn.DataAvailable += WaveIn_DataAvailable;
-            _waveIn.RecordingStopped += WaveIn_RecordingStopped;
-
-            _waveIn.StartRecording();
-
-            _audioManager = new AudioManager(_settingsManager);
-
-            _selectedChannelsManager.SelectedChannelsChanged += SelectedChannelsChanged;
-            Loaded += MainWindow_Loaded;
-        }
-
-        private void OpenCodeplug_Click(object sender, RoutedEventArgs e)
-        {
-            OpenFileDialog openFileDialog = new OpenFileDialog
-            {
-                Filter = "Codeplug Files (*.yml)|*.yml|All Files (*.*)|*.*",
-                Title = "Open Codeplug"
-            };
-            if (openFileDialog.ShowDialog() == true)
-            {
-                LoadCodeplug(openFileDialog.FileName);
-
-                _settingsManager.LastCodeplugPath = openFileDialog.FileName;
-                _settingsManager.SaveSettings();
-            }
-        }
-
-        private void ResetSettings_Click(object sender, RoutedEventArgs e)
-        {
-            if (File.Exists("UserSettings.json"))
-                File.Delete("UserSettings.json");
-        }
-
-        private void LoadCodeplug(string filePath)
-        {
-            try
-            {
-                var deserializer = new DeserializerBuilder()
-                    .WithNamingConvention(CamelCaseNamingConvention.Instance)
-                    .IgnoreUnmatchedProperties()
-                    .Build();
-
-                var yaml = File.ReadAllText(filePath);
-                Codeplug = deserializer.Deserialize<Codeplug>(yaml);
-
-                GenerateChannelWidgets();
-            }
-            catch (Exception ex)
-            {
-                MessageBox.Show($"Error loading codeplug: {ex.Message}", "Error", MessageBoxButton.OK, MessageBoxImage.Error);
-            }
-        }
-
-        private void GenerateChannelWidgets()
-        {
-            ChannelsCanvas.Children.Clear();
-            double offsetX = 20;
-            double offsetY = 20;
-
-            if (Codeplug != null)
-            {
-                foreach (var system in Codeplug.Systems)
-                {
-                    var systemStatusBox = new SystemStatusBox(system.Name, system.Address, system.Port);
-
-                    if (_settingsManager.SystemStatusPositions.TryGetValue(system.Name, out var position))
-                    {
-                        Canvas.SetLeft(systemStatusBox, position.X);
-                        Canvas.SetTop(systemStatusBox, position.Y);
-                    }
-                    else
-                    {
-                        Canvas.SetLeft(systemStatusBox, offsetX);
-                        Canvas.SetTop(systemStatusBox, offsetY);
-                    }
-
-                    systemStatusBox.MouseLeftButtonDown += SystemStatusBox_MouseLeftButtonDown;
-                    systemStatusBox.MouseMove += SystemStatusBox_MouseMove;
-                    systemStatusBox.MouseRightButtonDown += SystemStatusBox_MouseRightButtonDown;
-
-                    ChannelsCanvas.Children.Add(systemStatusBox);
-
-                    offsetX += 225;
-                    if (offsetX + 220 > ChannelsCanvas.ActualWidth)
-                    {
-                        offsetX = 20;
-                        offsetY += 106;
-                    }
-
-                    if (File.Exists(system.AliasPath))
-                        system.RidAlias = AliasTools.LoadAliases(system.AliasPath);
-
-                    if (!system.IsDvm)
-                    {
-                        _webSocketManager.AddWebSocketHandler(system.Name);
-
-                        IPeer handler = _webSocketManager.GetWebSocketHandler(system.Name);
-                        handler.OnVoiceChannelResponse += HandleVoiceResponse;
-                        handler.OnVoiceChannelRelease += HandleVoiceRelease;
-                        handler.OnEmergencyAlarmResponse += HandleEmergencyAlarmResponse;
-                        handler.OnAudioData += HandleReceivedAudio;
-                        handler.OnAffiliationUpdate += HandleAffiliationUpdate;
-                        handler.OnCallAlert += HandleCallAlert;
-
-                        handler.OnUnitRegistrationResponse += (response) =>
-                        {
-                            Dispatcher.Invoke(() =>
-                            {
-                                if (response.Status == (int)ResponseType.GRANT)
-                                {
-                                    systemStatusBox.Background = (Brush)new BrushConverter().ConvertFrom("#FF00BC48");
-                                    systemStatusBox.ConnectionState = "Connected";
-
-                                    foreach (ChannelBox channel in _selectedChannelsManager.GetSelectedChannels())
-                                    {
-                                        if (channel.SystemName == PLAYBACKSYS || channel.ChannelName == PLAYBACKCHNAME || channel.DstId == PLAYBACKTG)
-                                            continue;
-
-                                        Codeplug.System system = Codeplug.GetSystemForChannel(channel.ChannelName);
-                                        Codeplug.Channel cpgChannel = Codeplug.GetChannelByName(channel.ChannelName);
-
-                                        if (!system.IsDvm)
-                                        {
-                                            IPeer handler = _webSocketManager.GetWebSocketHandler(system.Name);
-
-                                            if (channel.IsSelected && handler.IsConnected)
-                                            {
-                                                Console.WriteLine("sending WLINK master aff");
-
-                                                Task.Run(() =>
-                                                {
-                                                    GRP_AFF_REQ release = new GRP_AFF_REQ
-                                                    {
-                                                        SrcId = system.Rid,
-                                                        DstId = cpgChannel.Tgid,
-                                                        Site = system.Site
-                                                    };
-
-                                                    handler.SendMessage(release.GetData());
-                                                });
-                                            }
-                                        }
-                                    }
-                                }
-                                else
-                                {
-                                    systemStatusBox.Background = new SolidColorBrush(Colors.Red);
-                                    systemStatusBox.ConnectionState = "Disconnected";
-                                }
-                            });
-                        };
-
-                        handler.OnClose += () =>
-                        {
-                            Dispatcher.Invoke(() =>
-                            {
-                                systemStatusBox.Background = new SolidColorBrush(Colors.Red);
-                                systemStatusBox.ConnectionState = "Disconnected";
-                            });
-                        };
-
-                        handler.OnOpen += () =>
-                        {
-                            Console.WriteLine("Peer connected");
-                            U_REG_REQ release = new U_REG_REQ
-                            {
-                                SrcId = system.Rid,
-                                Site = system.Site
-                            };
-
-                            handler.SendMessage(release.GetData());
-                        };
-
-                        handler.OnReconnecting += () =>
-                        {
-                            Console.WriteLine("Peer reconnecting");
-                        };
-
-                        Task.Run(() =>
-                        {
-                            handler.Connect(system.Address, system.Port, system.AuthKey);
-
-                            handler.OnGroupAffiliationResponse += (response) => { /* TODO */ };
-
-                            if (!handler.IsConnected)
-                            {
-                                systemStatusBox.Background = new SolidColorBrush(Colors.Red);
-                                systemStatusBox.ConnectionState = "Disconnected";
-                            }
-                        });
-                    } else
-                    {
-                        _fneSystemManager.AddFneSystem(system.Name, system, this);
-
-                        PeerSystem peer = _fneSystemManager.GetFneSystem(system.Name);
-
-                        peer.peer.PeerConnected += (sender, response) =>
-                        {
-                            Console.WriteLine("FNE Peer connected");
-
-                            Dispatcher.Invoke(() =>
-                            {
-                                systemStatusBox.Background = (Brush)new BrushConverter().ConvertFrom("#FF00BC48");
-                                systemStatusBox.ConnectionState = "Connected";
-                            });
-                        };
-
-
-                        peer.peer.PeerDisconnected += (response) =>
-                        {
-                            Console.WriteLine("FNE Peer disconnected");
-
-                            Dispatcher.Invoke(() =>
-                            {
-                                systemStatusBox.Background = new SolidColorBrush(Colors.Red);
-                                systemStatusBox.ConnectionState = "Disconnected";
-                            });
-                        };
-
-                        Task.Run(() =>
-                        {
-                            peer.Start();
-                        });
-                    }
-
-                    if (!_settingsManager.ShowSystemStatus)
-                        systemStatusBox.Visibility = Visibility.Collapsed;
-
-                }
-            }
-
-            if (_settingsManager.ShowChannels && Codeplug != null)
-            {
-                foreach (var zone in Codeplug.Zones)
-                {
-                    foreach (var channel in zone.Channels)
-                    {
-                        var channelBox = new ChannelBox(_selectedChannelsManager, _audioManager, channel.Name, channel.System, channel.Tgid);
-
-                        //channelBox.crypter.AddKey(channel.GetKeyId(), channel.GetAlgoId(), channel.GetEncryptionKey());
-
-                        systemStatuses.Add(channel.Name, new SlotStatus());
-
-                        if (_settingsManager.ChannelPositions.TryGetValue(channel.Name, out var position))
-                        {
-                            Canvas.SetLeft(channelBox, position.X);
-                            Canvas.SetTop(channelBox, position.Y);
-                        }
-                        else
-                        {
-                            Canvas.SetLeft(channelBox, offsetX);
-                            Canvas.SetTop(channelBox, offsetY);
-                        }
-
-                        channelBox.PTTButtonClicked += ChannelBox_PTTButtonClicked;
-                        channelBox.PageButtonClicked += ChannelBox_PageButtonClicked;
-                        channelBox.HoldChannelButtonClicked += ChannelBox_HoldChannelButtonClicked;
-
-                        channelBox.MouseLeftButtonDown += ChannelBox_MouseLeftButtonDown;
-                        channelBox.MouseMove += ChannelBox_MouseMove;
-                        channelBox.MouseRightButtonDown += ChannelBox_MouseRightButtonDown;
-                        ChannelsCanvas.Children.Add(channelBox);
-
-                        offsetX += 225;
-
-                        if (offsetX + 220 > ChannelsCanvas.ActualWidth)
-                        {
-                            offsetX = 20;
-                            offsetY += 106;
-                        }
-                    }
-                }
-            }
-
-            if (_settingsManager.ShowAlertTones && Codeplug != null)
-            {
-                foreach (var alertPath in _settingsManager.AlertToneFilePaths)
-                {
-                    var alertTone = new AlertTone(alertPath)
-                    {
-                        IsEditMode = isEditMode
-                    };
-
-                    alertTone.OnAlertTone += SendAlertTone;
-
-                    if (_settingsManager.AlertTonePositions.TryGetValue(alertPath, out var position))
-                    {
-                        Canvas.SetLeft(alertTone, position.X);
-                        Canvas.SetTop(alertTone, position.Y);
-                    }
-                    else
-                    {
-                        Canvas.SetLeft(alertTone, 20);
-                        Canvas.SetTop(alertTone, 20);
-                    }
-
-                    alertTone.MouseRightButtonUp += AlertTone_MouseRightButtonUp;
-
-                    ChannelsCanvas.Children.Add(alertTone);
-                }
-            }
-
-            playbackChannelBox = new ChannelBox(_selectedChannelsManager, _audioManager, PLAYBACKCHNAME, PLAYBACKSYS, PLAYBACKTG);
-
-            if (_settingsManager.ChannelPositions.TryGetValue(PLAYBACKCHNAME, out var pos))
-            {
-                Canvas.SetLeft(playbackChannelBox, pos.X);
-                Canvas.SetTop(playbackChannelBox, pos.Y);
-            }
-            else
-            {
-                Canvas.SetLeft(playbackChannelBox, offsetX);
-                Canvas.SetTop(playbackChannelBox, offsetY);
-            }
-
-            playbackChannelBox.PTTButtonClicked += ChannelBox_PTTButtonClicked;
-            playbackChannelBox.PageButtonClicked += ChannelBox_PageButtonClicked;
-            playbackChannelBox.HoldChannelButtonClicked += ChannelBox_HoldChannelButtonClicked;
-
-            playbackChannelBox.MouseLeftButtonDown += ChannelBox_MouseLeftButtonDown;
-            playbackChannelBox.MouseMove += ChannelBox_MouseMove;
-            playbackChannelBox.MouseRightButtonDown += ChannelBox_MouseRightButtonDown;
-            ChannelsCanvas.Children.Add(playbackChannelBox);
-
-            //offsetX += 225;
-
-            //if (offsetX + 220 > ChannelsCanvas.ActualWidth)
-            //{
-            //    offsetX = 20;
-            //    offsetY += 106;
-            //}
-
-            AdjustCanvasHeight();
-        }
-
-        private void WaveIn_RecordingStopped(object sender, EventArgs e)
-        {
-            /* stub */
-        }
-
-        private void WaveIn_DataAvailable(object sender, WaveInEventArgs e)
-        {
-            bool isAnyTgOn = false;
-
-            foreach (ChannelBox channel in _selectedChannelsManager.GetSelectedChannels())
-            {
-                if (channel.SystemName == PLAYBACKSYS || channel.ChannelName == PLAYBACKCHNAME || channel.DstId == PLAYBACKTG)
-                {
-                    playbackChannelBox.IsReceiving = true;
-                    continue;
-                }
-
-                Codeplug.System system = Codeplug.GetSystemForChannel(channel.ChannelName);
-                Codeplug.Channel cpgChannel = Codeplug.GetChannelByName(channel.ChannelName);
-
-                Task.Run(() =>
-                {
-
-                    if (!system.IsDvm)
-                    {
-                        IPeer handler = _webSocketManager.GetWebSocketHandler(system.Name);
-
-                        if (channel.IsSelected && channel.VoiceChannel != null && channel.PttState)
-                        {
-                            isAnyTgOn = true;
-
-                            object voicePaket = new
-                            {
-                                type = PacketType.AUDIO_DATA,
-                                data = new
-                                {
-                                    Data = e.Buffer,
-                                    VoiceChannel = new VoiceChannel
-                                    {
-                                        Frequency = channel.VoiceChannel,
-                                        DstId = cpgChannel.Tgid,
-                                        SrcId = system.Rid,
-                                        Site = system.Site
-                                    },
-                                    Site = system.Site
-                                }
-                            };
-
-#if DEBUG
-                            Console.WriteLine($"WLINK AUDIO_DATA SrcId: {system.Rid}; DstId: {cpgChannel.Tgid}; Freq: {channel.VoiceChannel}");
-#endif
-
-                            handler.SendMessage(voicePaket);
-                        }
-                    }
-                    else
-                    {
-                        PeerSystem handler = _fneSystemManager.GetFneSystem(system.Name);
-
-                        if (channel.IsSelected && channel.PttState)
-                        {
-                            isAnyTgOn = true;
-
-                            int samples = 320;
-
-                            channel.chunkedPcm = AudioConverter.SplitToChunks(e.Buffer);
-
-                            foreach (byte[] chunk in channel.chunkedPcm)
-                            {
-                                if (chunk.Length == samples)
-                                {
-                                    P25EncodeAudioFrame(chunk, handler, channel, cpgChannel, system);
-                                }
-                                else
-                                {
-                                    Console.WriteLine("bad sample length: " + chunk.Length);
-                                }
-                            }
-                        }
-                    }
-                });
-            }
-
-            if (isAnyTgOn && playbackChannelBox.IsSelected)
-                _audioManager.AddTalkgroupStream(PLAYBACKTG, e.Buffer);
-        }
-
-        private void SelectedChannelsChanged()
-        {
-            foreach (ChannelBox channel in _selectedChannelsManager.GetSelectedChannels())
-            {
-                if (channel.SystemName == PLAYBACKSYS || channel.ChannelName == PLAYBACKCHNAME || channel.DstId == PLAYBACKTG)
-                    continue;
-
-                Codeplug.System system = Codeplug.GetSystemForChannel(channel.ChannelName);
-                Codeplug.Channel cpgChannel = Codeplug.GetChannelByName(channel.ChannelName);
-         
-                if (!system.IsDvm) {
-                    IPeer handler = _webSocketManager.GetWebSocketHandler(system.Name);
-
-                    if (channel.IsSelected && handler.IsConnected)
-                    {
-                        Console.WriteLine("sending WLINK master aff");
-
-                        Task.Run(() =>
-                        {
-                            GRP_AFF_REQ release = new GRP_AFF_REQ
-                            {
-                                SrcId = system.Rid,
-                                DstId = cpgChannel.Tgid,
-                                Site = system.Site
-                            };
-
-                            handler.SendMessage(release.GetData());
-                        });
-                    }
-                } else
-                {
-                    PeerSystem fne = _fneSystemManager.GetFneSystem(system.Name);
-
-                    if (channel.IsSelected)
-                    {
-                        uint newTgid = UInt32.Parse(cpgChannel.Tgid);
-                        bool exists = fneAffs.Any(aff => aff.Item2 == newTgid);
-
-                        if (cpgChannel.GetAlgoId() != 0 && cpgChannel.GetKeyId() != 0)
-                            fne.peer.SendMasterKeyRequest(cpgChannel.GetAlgoId(), cpgChannel.GetKeyId());
-
-                        if (!exists)
-                            fneAffs.Add(new Tuple<uint, uint>(GetUniqueRid(system.Rid), newTgid));
-
-                        //Console.WriteLine("FNE Affiliations:");
-                        //foreach (var aff in fneAffs)
-                        //{
-                        //    Console.WriteLine($"  RID: {aff.Item1}, TGID: {aff.Item2}");
-                        //}
-                    }
-                }
-            }
-
-            foreach (Codeplug.System system in Codeplug.Systems)
-            {
-                if (system.IsDvm)
-                {
-                    PeerSystem fne = _fneSystemManager.GetFneSystem(system.Name);
-                    //fne.peer.SendMasterAffiliationUpdate(fneAffs);
-                }
-            }
-        }
-
-        private void AudioSettings_Click(object sender, RoutedEventArgs e)
-        {
-            List<Codeplug.Channel> channels = Codeplug?.Zones.SelectMany(z => z.Channels).ToList() ?? new List<Codeplug.Channel>();
-
-            AudioSettingsWindow audioSettingsWindow = new AudioSettingsWindow(_settingsManager, _audioManager, channels);
-            audioSettingsWindow.ShowDialog();
-        }
-
-        private void P25Page_Click(object sender, RoutedEventArgs e)
-        {
-            DigitalPageWindow pageWindow = new DigitalPageWindow(Codeplug.Systems);
-            pageWindow.Owner = this;
-            if (pageWindow.ShowDialog() == true)
-            {
-                if (!pageWindow.RadioSystem.IsDvm)
-                {
-                    IPeer handler = _webSocketManager.GetWebSocketHandler(pageWindow.RadioSystem.Name);
-
-                    CALL_ALRT_REQ callAlert = new CALL_ALRT_REQ
-                    {
-                        SrcId = pageWindow.RadioSystem.Rid,
-                        DstId = pageWindow.DstId
-                    };
-
-                    handler.SendMessage(callAlert.GetData());
-                }
-                else
-                {
-                    PeerSystem handler = _fneSystemManager.GetFneSystem(pageWindow.RadioSystem.Name);
-                    IOSP_CALL_ALRT callAlert = new IOSP_CALL_ALRT(UInt32.Parse(pageWindow.DstId), UInt32.Parse(pageWindow.RadioSystem.Rid));
-
-                    RemoteCallData callData = new RemoteCallData
-                    {
-                        SrcId = UInt32.Parse(pageWindow.RadioSystem.Rid),
-                        DstId = UInt32.Parse(pageWindow.DstId),
-                        LCO = P25Defines.TSBK_IOSP_CALL_ALRT
-                    };
-
-                    byte[] tsbk = new byte[P25Defines.P25_TSBK_LENGTH_BYTES];
-
-                    callAlert.Encode(ref tsbk, true, true);
-
-                    handler.SendP25TSBK(callData, tsbk);
-
-                    Console.WriteLine("sent page");
-                }
-            }
-        }
-
-        private async void ManualPage_Click(object sender, RoutedEventArgs e)
-        {
-            QuickCallPage pageWindow = new QuickCallPage();
-            pageWindow.Owner = this;
-            if (pageWindow.ShowDialog() == true)
-            {
-                foreach (ChannelBox channel in _selectedChannelsManager.GetSelectedChannels())
-                {
-                    Codeplug.System system = Codeplug.GetSystemForChannel(channel.ChannelName);
-                    Codeplug.Channel cpgChannel = Codeplug.GetChannelByName(channel.ChannelName);
-
-                    if (channel.PageState)
-                    {
-                        ToneGenerator generator = new ToneGenerator();
-
-                        double toneADuration = 1.0;
-                        double toneBDuration = 3.0;
-
-                        byte[] toneA = generator.GenerateTone(Double.Parse(pageWindow.ToneA), toneADuration);
-                        byte[] toneB = generator.GenerateTone(Double.Parse(pageWindow.ToneB), toneBDuration);
-
-                        byte[] combinedAudio = new byte[toneA.Length + toneB.Length];
-                        Buffer.BlockCopy(toneA, 0, combinedAudio, 0, toneA.Length);
-                        Buffer.BlockCopy(toneB, 0, combinedAudio, toneA.Length, toneB.Length);
-
-                        int chunkSize = 1600;
-
-                        if (system.IsDvm)
-                            chunkSize = 320;
-
-                        int totalChunks = (combinedAudio.Length + chunkSize - 1) / chunkSize;
-
-                        Task.Run(() =>
-                        {
-                            //_waveProvider.ClearBuffer();
-                            _audioManager.AddTalkgroupStream(cpgChannel.Tgid, combinedAudio);
-                        });
-
-                        await Task.Run(() =>
-                        {
-                            for (int i = 0; i < totalChunks; i++)
-                            {
-                                int offset = i * chunkSize;
-                                int size = Math.Min(chunkSize, combinedAudio.Length - offset);
-
-                                byte[] chunk = new byte[chunkSize];
-                                Buffer.BlockCopy(combinedAudio, offset, chunk, 0, size);
-
-                                if (!system.IsDvm)
-                                {
-                                    IPeer handler = _webSocketManager.GetWebSocketHandler(system.Name);
-
-                                    AudioPacket voicePacket = new AudioPacket
-                                    {
-                                        Data = chunk,
-                                        VoiceChannel = new VoiceChannel
-                                        {
-                                            Frequency = channel.VoiceChannel,
-                                            DstId = cpgChannel.Tgid,
-                                            SrcId = system.Rid,
-                                            Site = system.Site
-                                        },
-                                        Site = system.Site,
-                                        LopServerVocode = true
-                                    };
-
-                                    handler.SendMessage(voicePacket.GetData());
-                                } else
-                                {
-                                    PeerSystem handler = _fneSystemManager.GetFneSystem(system.Name);
-
-                                    if (chunk.Length == 320)
-                                    {
-                                        P25EncodeAudioFrame(chunk, handler, channel, cpgChannel, system);
-                                    }
-                                }
-                            }
-                        });
-
-                        double totalDurationMs = (toneADuration + toneBDuration) * 1000 + 750;
-                        await Task.Delay((int)totalDurationMs);
-
-                        if (!system.IsDvm)
-                        {
-                            IPeer handler = _webSocketManager.GetWebSocketHandler(system.Name);
-
-                            GRP_VCH_RLS release = new GRP_VCH_RLS
-                            {
-                                SrcId = system.Rid,
-                                DstId = cpgChannel.Tgid,
-                                Channel = channel.VoiceChannel,
-                                Site = system.Site
-                            };
-
-                            handler.SendMessage(release.GetData());
-                        } else
-                        {
-                            PeerSystem handler = _fneSystemManager.GetFneSystem(system.Name);
-
-                            await Task.Delay(4000);
-
-                            handler.SendP25TDU(UInt32.Parse(system.Rid), UInt32.Parse(cpgChannel.Tgid), false);
-                        }
-
-                        Dispatcher.Invoke(() =>
-                        {
-                            //channel.PageState = false; // TODO: Investigate
-                            channel.PageSelectButton.Background = channel.grayGradient;
-                        });
-                    }
-                }
-            }
-        }
-
-        private void SendAlertTone(AlertTone e)
-        {
-            Task.Run(() => SendAlertTone(e.AlertFilePath));
-        }
-
-        private void SendAlertTone(string filePath, bool forHold = false)
-        {
-            if (!string.IsNullOrEmpty(filePath) && File.Exists(filePath))
-            {
-                try
-                {
-                    foreach (ChannelBox channel in _selectedChannelsManager.GetSelectedChannels())
-                    {
-                        if (channel.SystemName == PLAYBACKSYS || channel.ChannelName == PLAYBACKCHNAME || channel.DstId == PLAYBACKTG)
-                            continue;
-
-                        Codeplug.System system = Codeplug.GetSystemForChannel(channel.ChannelName);
-                        Codeplug.Channel cpgChannel = Codeplug.GetChannelByName(channel.ChannelName);
-
-                        if (channel.PageState || (forHold && channel.HoldState))
-                        {
-                            byte[] pcmData;
-
-                            Task.Run(async () => {
-                                using (var waveReader = new WaveFileReader(filePath))
-                                {
-                                    if (waveReader.WaveFormat.Encoding != WaveFormatEncoding.Pcm ||
-                                        waveReader.WaveFormat.SampleRate != 8000 ||
-                                        waveReader.WaveFormat.BitsPerSample != 16 ||
-                                        waveReader.WaveFormat.Channels != 1)
-                                    {
-                                        MessageBox.Show("The alert tone must be PCM 16-bit, Mono, 8000Hz format.", "Error", MessageBoxButton.OK, MessageBoxImage.Error);
-                                        return;
-                                    }
-
-                                    using (MemoryStream ms = new MemoryStream())
-                                    {
-                                        waveReader.CopyTo(ms);
-                                        pcmData = ms.ToArray();
-                                    }
-                                }
-
-                                int chunkSize = 1600;
-                                int totalChunks = (pcmData.Length + chunkSize - 1) / chunkSize;
-
-                                if (pcmData.Length % chunkSize != 0)
-                                {
-                                    byte[] paddedData = new byte[totalChunks * chunkSize];
-                                    Buffer.BlockCopy(pcmData, 0, paddedData, 0, pcmData.Length);
-                                    pcmData = paddedData;
-                                }
-
-                                Task.Run(() =>
-                                {
-                                    _audioManager.AddTalkgroupStream(cpgChannel.Tgid, pcmData);
-                                });
-
-                                DateTime startTime = DateTime.UtcNow;
-
-                                for (int i = 0; i < totalChunks; i++)
-                                {
-                                    int offset = i * chunkSize;
-                                    byte[] chunk = new byte[chunkSize];
-                                    Buffer.BlockCopy(pcmData, offset, chunk, 0, chunkSize);
-
-                                    if (!system.IsDvm)
-                                    {
-                                        IPeer handler = _webSocketManager.GetWebSocketHandler(system.Name);
-
-                                        AudioPacket voicePacket = new AudioPacket
-                                        {
-                                            Data = chunk,
-                                            VoiceChannel = new VoiceChannel
-                                            {
-                                                Frequency = channel.VoiceChannel,
-                                                DstId = cpgChannel.Tgid,
-                                                SrcId = system.Rid,
-                                                Site = system.Site
-                                            },
-                                            Site = system.Site,
-                                            LopServerVocode = true
-                                        };
-
-                                        handler.SendMessage(voicePacket.GetData());
-                                    }
-                                    else
-                                    {
-                                        PeerSystem handler = _fneSystemManager.GetFneSystem(system.Name);
-
-                                        channel.chunkedPcm = AudioConverter.SplitToChunks(chunk);
-
-                                        foreach (byte[] smallchunk in channel.chunkedPcm)
-                                        {
-                                            if (smallchunk.Length == 320)
-                                            {
-                                                P25EncodeAudioFrame(smallchunk, handler, channel, cpgChannel, system);
-                                            }
-                                        }
-                                    }
-
-                                    DateTime nextPacketTime = startTime.AddMilliseconds((i + 1) * 100);
-                                    TimeSpan waitTime = nextPacketTime - DateTime.UtcNow;
-
-                                    if (waitTime.TotalMilliseconds > 0)
-                                    {
-                                        await Task.Delay(waitTime);
-                                    }
-                                }
-
-                                double totalDurationMs = ((double)pcmData.Length / 16000) + 250;
-                                await Task.Delay((int)totalDurationMs);
-
-                                if (!system.IsDvm)
-                                {
-                                    IPeer handler = _webSocketManager.GetWebSocketHandler(system.Name);
-
-                                    GRP_VCH_RLS release = new GRP_VCH_RLS
-                                    {
-                                        SrcId = system.Rid,
-                                        DstId = cpgChannel.Tgid,
-                                        Channel = channel.VoiceChannel,
-                                        Site = system.Site
-                                    };
-
-                                    Dispatcher.Invoke(() =>
-                                    {
-                                        handler.SendMessage(release.GetData());
-
-                                        if (forHold)
-                                            channel.PttButton.Background = channel.grayGradient;
-                                        else
-                                            channel.PageState = false;
-                                    });
-                                } else
-                                {
-                                    PeerSystem handler = _fneSystemManager.GetFneSystem(system.Name);
-
-                                    await Task.Delay(3000);
-
-                                    handler.SendP25TDU(UInt32.Parse(system.Rid), UInt32.Parse(cpgChannel.Tgid), false);
-
-                                    Dispatcher.Invoke(() =>
-                                    {
-                                        if (forHold)
-                                            channel.PttButton.Background = channel.grayGradient;
-                                        else
-                                            channel.PageState = false;
-                                    });
-                                }
-                            });
-                        }
-                    }
-                }
-                catch (Exception ex)
-                {
-                    MessageBox.Show($"Failed to process alert tone: {ex.Message}", "Error", MessageBoxButton.OK, MessageBoxImage.Error);
-                }
-            }
-            else
-            {
-                MessageBox.Show("Alert file not set or file not found.", "Alert", MessageBoxButton.OK, MessageBoxImage.Warning);
-            }
-        }
-
-        private void SelectWidgets_Click(object sender, RoutedEventArgs e)
-        {
-            WidgetSelectionWindow widgetSelectionWindow = new WidgetSelectionWindow();
-            widgetSelectionWindow.Owner = this;
-            if (widgetSelectionWindow.ShowDialog() == true)
-            {
-                _settingsManager.ShowSystemStatus = widgetSelectionWindow.ShowSystemStatus;
-                _settingsManager.ShowChannels = widgetSelectionWindow.ShowChannels;
-                _settingsManager.ShowAlertTones = widgetSelectionWindow.ShowAlertTones;
-
-                GenerateChannelWidgets();
-                _settingsManager.SaveSettings();
-            }
-        }
-
-        private void HandleEmergencyAlarmResponse(EMRG_ALRM_RSP response)
-        {
-            bool forUs = false;
-
-            foreach (ChannelBox channel in _selectedChannelsManager.GetSelectedChannels())
-            {
-                Codeplug.System system = Codeplug.GetSystemForChannel(channel.ChannelName);
-                Codeplug.Channel cpgChannel = Codeplug.GetChannelByName(channel.ChannelName);
-
-                if (response.DstId == cpgChannel.Tgid)
-                {
-                    forUs = true;
-                    channel.Emergency = true;
-                    channel.LastSrcId = response.SrcId;
-                }
-            }
-
-            if (forUs)
-            {
-                Dispatcher.Invoke(() =>
-                {
-                    _flashingManager.Start();
-                    _emergencyAlertPlayback.Start();
-                });
-            }
-        }
-
-        private void HandleCallAlert(CALL_ALRT request)
-        {
-            foreach (ChannelBox channel in _selectedChannelsManager.GetSelectedChannels())
-            {
-                Codeplug.System system = Codeplug.GetSystemForChannel(channel.ChannelName);
-                Codeplug.Channel cpgChannel = Codeplug.GetChannelByName(channel.ChannelName);
-
-                if (system.IsDvm)
-                    continue;
-
-                IPeer handler = _webSocketManager.GetWebSocketHandler(system.Name);
-
-                if (request.DstId == system.Rid)
-                {
-
-                    ACK_RSP ack = new ACK_RSP
-                    {
-                        SrcId = request.SrcId,
-                        DstId = request.DstId,
-                        Service = PacketType.CALL_ALRT
-                    };
-
-                    handler.SendMessage(ack.GetData());
-                }
-            }
-        }
-
-        private void HandleReceivedAudio(AudioPacket audioPacket)
-        {
-            bool shouldReceive = false;
-            string talkgroupId = audioPacket.VoiceChannel.DstId;
-
-            foreach (ChannelBox channel in _selectedChannelsManager.GetSelectedChannels())
-            {
-                if (channel.SystemName == PLAYBACKSYS || channel.ChannelName == PLAYBACKCHNAME || channel.DstId == PLAYBACKTG)
-                    continue;
-
-                Codeplug.System system = Codeplug.GetSystemForChannel(channel.ChannelName);
-                Codeplug.Channel cpgChannel = Codeplug.GetChannelByName(channel.ChannelName);
-
-                if (system.IsDvm)
-                    continue;
-
-                if (audioPacket.VoiceChannel.SrcId != system.Rid && audioPacket.VoiceChannel.Frequency == channel.VoiceChannel && audioPacket.VoiceChannel.DstId == cpgChannel.Tgid)
-                    shouldReceive = true;
-            }
-
-            if (shouldReceive)
-                _audioManager.AddTalkgroupStream(talkgroupId, audioPacket.Data);
-        }
-
-        private void HandleAffiliationUpdate(AFF_UPDATE affUpdate)
-        {
-            foreach (ChannelBox channel in _selectedChannelsManager.GetSelectedChannels())
-            {
-                if (channel.SystemName == PLAYBACKSYS || channel.ChannelName == PLAYBACKCHNAME || channel.DstId == PLAYBACKTG)
-                    continue;
-
-                Codeplug.System system = Codeplug.GetSystemForChannel(channel.ChannelName);
-                Codeplug.Channel cpgChannel = Codeplug.GetChannelByName(channel.ChannelName);
-
-                if (system.IsDvm)
-                    continue;
-
-                IPeer handler = _webSocketManager.GetWebSocketHandler(system.Name);
-
-                bool ridExists = affUpdate.Affiliations.Any(aff => aff.SrcId == system.Rid);
-                bool tgidExists = affUpdate.Affiliations.Any(aff => aff.DstId == cpgChannel.Tgid);
-
-                if (ridExists && tgidExists)
-                {
-                    //Console.WriteLine("rid aff'ed");
-                }
-                else
-                {
-                    //Console.WriteLine("rid not aff'ed");
-                    Task.Run(() =>
-                    {
-                        GRP_AFF_REQ affReq = new GRP_AFF_REQ
-                        {
-                            SrcId = system.Rid,
-                            DstId = cpgChannel.Tgid,
-                            Site = system.Site
-                        };
-
-                        handler.SendMessage(affReq.GetData());
-                    });
-                }
-            }
-        }
-
-        private void HandleVoiceRelease(GRP_VCH_RLS response)
-        {
-            foreach (ChannelBox channel in _selectedChannelsManager.GetSelectedChannels())
-            {
-                if (channel.SystemName == PLAYBACKSYS || channel.ChannelName == PLAYBACKCHNAME || channel.DstId == PLAYBACKTG)
-                    continue;
-
-                Codeplug.System system = Codeplug.GetSystemForChannel(channel.ChannelName);
-                Codeplug.Channel cpgChannel = Codeplug.GetChannelByName(channel.ChannelName);
-
-                if (system.IsDvm)
-                    continue;
-
-                IPeer handler = _webSocketManager.GetWebSocketHandler(system.Name);
-
-                if (response.DstId == cpgChannel.Tgid && response.SrcId != system.Rid)
-                {
-                    Dispatcher.Invoke(() =>
-                    {
-                        if (channel.IsSelected)
-                        {
-                            channel.Background = (Brush)new BrushConverter().ConvertFrom("#FF0B004B");
-                            channel.IsReceiving = false;
-                        }
-                        else
-                        {
-                            channel.Background = new SolidColorBrush(Colors.DarkGray);
-                            channel.IsReceiving = false;
-                        }
-                    });
-
-                    channel.VoiceChannel = null;
-                }
-            }
-        }
-
-        private void HandleVoiceResponse(GRP_VCH_RSP response)
-        {
-            foreach (ChannelBox channel in _selectedChannelsManager.GetSelectedChannels())
-            {
-                if (channel.SystemName == PLAYBACKSYS || channel.ChannelName == PLAYBACKCHNAME || channel.DstId == PLAYBACKTG)
-                    continue;
-
-                Codeplug.System system = Codeplug.GetSystemForChannel(channel.ChannelName);
-                Codeplug.Channel cpgChannel = Codeplug.GetChannelByName(channel.ChannelName);
-
-                if (system.IsDvm)
-                    continue;
-
-                IPeer handler = _webSocketManager.GetWebSocketHandler(system.Name);
-
-                if (channel.PttState && response.Status == (int)ResponseType.GRANT && response.Channel != null && response.SrcId == system.Rid && response.DstId == cpgChannel.Tgid)
-                {
-                    channel.VoiceChannel = response.Channel;
-                }
-                else if (response.Status == (int)ResponseType.GRANT && response.SrcId != system.Rid && response.DstId == cpgChannel.Tgid)
-                {
-                    channel.VoiceChannel = response.Channel;
-
-                    string alias = string.Empty;
-
-                    try
-                    {
-                        alias = AliasTools.GetAliasByRid(system.RidAlias, int.Parse(response.SrcId));
-                    }
-                    catch (Exception) { }
-
-                    if (alias.IsNullOrEmpty())
-                        channel.LastSrcId = "Last SRC: " + response.SrcId;
-                    else
-                        channel.LastSrcId = "Last: " + alias;
-
-                    Dispatcher.Invoke(() =>
-                    {
-                        channel.Background = (Brush)new BrushConverter().ConvertFrom("#FF00BC48");
-                        channel.IsReceiving = true;
-                    });
-                }
-                else if ((channel.HoldState || channel.PageState) && response.Status == (int)ResponseType.GRANT && response.Channel != null && response.SrcId == system.Rid && response.DstId == cpgChannel.Tgid)
-                {
-                    channel.VoiceChannel = response.Channel;
-                }
-                else
-                {
-                    //Dispatcher.Invoke(() =>
-                    //{
-                    //    if (channel.IsSelected)
-                    //        channel.Background = new SolidColorBrush(Colors.DodgerBlue);
-                    //    else
-                    //        channel.Background = new SolidColorBrush(Colors.Gray);
-                    //});
-
-                    //channel.VoiceChannel = null;
-                    //_stopSending = true;
-                }
-            }
-        }
-
-        private void ChannelBox_HoldChannelButtonClicked(object sender, ChannelBox e)
-        {
-            if (e.SystemName == PLAYBACKSYS || e.ChannelName == PLAYBACKCHNAME || e.DstId == PLAYBACKTG)
-                return;
-
-            Codeplug.System system = Codeplug.GetSystemForChannel(e.ChannelName);
-            Codeplug.Channel cpgChannel = Codeplug.GetChannelByName(e.ChannelName);
-
-            if (system.IsDvm)
-                return;
-
-            IPeer handler = _webSocketManager.GetWebSocketHandler(system.Name);
-        }
-
-        private void ChannelBox_PageButtonClicked(object sender, ChannelBox e)
-        {
-            if (e.SystemName == PLAYBACKSYS || e.ChannelName == PLAYBACKCHNAME || e.DstId == PLAYBACKTG)
-                return;
-
-            Codeplug.System system = Codeplug.GetSystemForChannel(e.ChannelName);
-            Codeplug.Channel cpgChannel = Codeplug.GetChannelByName(e.ChannelName);
-
-            if (!system.IsDvm)
-            {
-
-                IPeer handler = _webSocketManager.GetWebSocketHandler(system.Name);
-
-                if (e.PageState)
-                {
-                    GRP_VCH_REQ request = new GRP_VCH_REQ
-                    {
-                        SrcId = system.Rid,
-                        DstId = cpgChannel.Tgid,
-                        Site = system.Site
-                    };
-
-                    handler.SendMessage(request.GetData());
-                }
-                else
-                {
-                    GRP_VCH_RLS release = new GRP_VCH_RLS
-                    {
-                        SrcId = system.Rid,
-                        DstId = cpgChannel.Tgid,
-                        Channel = e.VoiceChannel,
-                        Site = system.Site
-                    };
-
-                    handler.SendMessage(release.GetData());
-                    e.VoiceChannel = null;
-                }
-            }
-            else
-            {
-                PeerSystem handler = _fneSystemManager.GetFneSystem(system.Name);
-                if (e.PageState)
-                {
-                    handler.SendP25TDU(UInt32.Parse(system.Rid), UInt32.Parse(cpgChannel.Tgid), true);
-                }
-                else
-                {
-                    handler.SendP25TDU(UInt32.Parse(system.Rid), UInt32.Parse(cpgChannel.Tgid), false);
-                }
-            }
-        }
-
-        private void ChannelBox_PTTButtonClicked(object sender, ChannelBox e)
-        {
-            if (e.SystemName == PLAYBACKSYS || e.ChannelName == PLAYBACKCHNAME || e.DstId == PLAYBACKTG)
-                return;
-
-            Codeplug.System system = Codeplug.GetSystemForChannel(e.ChannelName);
-            Codeplug.Channel cpgChannel = Codeplug.GetChannelByName(e.ChannelName);
-
-            if (!system.IsDvm)
-            {
-                IPeer handler = _webSocketManager.GetWebSocketHandler(system.Name);
-
-                if (!e.IsSelected)
-                    return;
-
-                if (e.PttState)
-                {
-                    GRP_VCH_REQ request = new GRP_VCH_REQ
-                    {
-                        SrcId = system.Rid,
-                        DstId = cpgChannel.Tgid,
-                        Site = system.Site
-                    };
-
-                    handler.SendMessage(request.GetData());
-                }
-                else
-                {
-                    GRP_VCH_RLS release = new GRP_VCH_RLS
-                    {
-                        SrcId = system.Rid,
-                        DstId = cpgChannel.Tgid,
-                        Channel = e.VoiceChannel,
-                        Site = system.Site
-                    };
-
-                    handler.SendMessage(release.GetData());
-                    e.VoiceChannel = null;
-                }
-            } else
-            {
-                PeerSystem handler = _fneSystemManager.GetFneSystem(system.Name);
-
-                if (!e.IsSelected)
-                    return;
-
-                FneUtils.Memset(e.mi, 0x00, P25Defines.P25_MI_LENGTH);
-
-                uint srcId = UInt32.Parse(system.Rid);
-                uint dstId = UInt32.Parse(cpgChannel.Tgid);
-
-                if (e.PttState)
-                {
-                    e.txStreamId = handler.NewStreamId();
-
-                    Console.WriteLine("sending grant demand " + dstId);
-                    handler.SendP25TDU(srcId, dstId, true);
-                }
-                else
-                {
-                    Console.WriteLine("sending terminator " + dstId);
-                    handler.SendP25TDU(srcId, dstId, false);
-                }
-            }
-        }
-
-        private void ChannelBox_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
-        {
-            if (!isEditMode || !(sender is UIElement element)) return;
-
-            _draggedElement = element;
-            _startPoint = e.GetPosition(ChannelsCanvas);
-            _offsetX = _startPoint.X - Canvas.GetLeft(_draggedElement);
-            _offsetY = _startPoint.Y - Canvas.GetTop(_draggedElement);
-            _isDragging = true;
-
-            element.CaptureMouse();
-        }
-
-        private const int GridSize = 5;
-
-        private void ChannelBox_MouseMove(object sender, MouseEventArgs e)
-        {
-            if (!isEditMode || !_isDragging || _draggedElement == null) return;
-
-            Point currentPosition = e.GetPosition(ChannelsCanvas);
-
-            // Calculate the new position with snapping to the grid
-            double newLeft = Math.Round((currentPosition.X - _offsetX) / GridSize) * GridSize;
-            double newTop = Math.Round((currentPosition.Y - _offsetY) / GridSize) * GridSize;
-
-            // Ensure the box stays within canvas bounds
-            newLeft = Math.Max(0, Math.Min(newLeft, ChannelsCanvas.ActualWidth - _draggedElement.RenderSize.Width));
-            newTop = Math.Max(0, Math.Min(newTop, ChannelsCanvas.ActualHeight - _draggedElement.RenderSize.Height));
-
-            // Apply snapped position
-            Canvas.SetLeft(_draggedElement, newLeft);
-            Canvas.SetTop(_draggedElement, newTop);
-
-            // Save the new position if it's a ChannelBox
-            if (_draggedElement is ChannelBox channelBox)
-            {
-                _settingsManager.UpdateChannelPosition(channelBox.ChannelName, newLeft, newTop);
-            }
-
-            AdjustCanvasHeight();
-        }
-
-        private void ChannelBox_MouseRightButtonDown(object sender, MouseButtonEventArgs e)
-        {
-            if (!isEditMode || !_isDragging || _draggedElement == null) return;
-
-            _isDragging = false;
-            _draggedElement.ReleaseMouseCapture();
-            _draggedElement = null;
-        }
-
-        private void SystemStatusBox_MouseLeftButtonDown(object sender, MouseButtonEventArgs e) => ChannelBox_MouseLeftButtonDown(sender, e);
-        private void SystemStatusBox_MouseMove(object sender, MouseEventArgs e) => ChannelBox_MouseMove(sender, e);
-
-        private void SystemStatusBox_MouseRightButtonDown(object sender, MouseButtonEventArgs e)
-        {
-            if (!isEditMode) return;
-
-            if (sender is SystemStatusBox systemStatusBox)
-            {
-                double x = Canvas.GetLeft(systemStatusBox);
-                double y = Canvas.GetTop(systemStatusBox);
-                _settingsManager.SystemStatusPositions[systemStatusBox.SystemName] = new ChannelPosition { X = x, Y = y };
-
-                ChannelBox_MouseRightButtonDown(sender, e);
-
-                AdjustCanvasHeight();
-            }
-        }
-
-        private void ToggleEditMode_Click(object sender, RoutedEventArgs e)
-        {
-            isEditMode = !isEditMode;
-            var menuItem = (MenuItem)sender;
-            menuItem.Header = isEditMode ? "Disable Edit Mode" : "Enable Edit Mode";
-            UpdateEditModeForWidgets();
-        }
-
-        private void UpdateEditModeForWidgets()
-        {
-            foreach (var child in ChannelsCanvas.Children)
-            {
-                if (child is AlertTone alertTone)
-                {
-                    alertTone.IsEditMode = isEditMode;
-                }
-
-                if (child is ChannelBox channelBox)
-                {
-                    channelBox.IsEditMode = isEditMode;
-                }
-            }
-        }
-
-        private void AddAlertTone_Click(object sender, RoutedEventArgs e)
-        {
-            OpenFileDialog openFileDialog = new OpenFileDialog
-            {
-                Filter = "WAV Files (*.wav)|*.wav|All Files (*.*)|*.*",
-                Title = "Select Alert Tone"
-            };
-
-            if (openFileDialog.ShowDialog() == true)
-            {
-                string alertFilePath = openFileDialog.FileName;
-                var alertTone = new AlertTone(alertFilePath)
-                {
-                    IsEditMode = isEditMode
-                };
-
-                alertTone.OnAlertTone += SendAlertTone;
-
-                if (_settingsManager.AlertTonePositions.TryGetValue(alertFilePath, out var position))
-                {
-                    Canvas.SetLeft(alertTone, position.X);
-                    Canvas.SetTop(alertTone, position.Y);
-                }
-                else
-                {
-                    Canvas.SetLeft(alertTone, 20);
-                    Canvas.SetTop(alertTone, 20);
-                }
-
-                alertTone.MouseRightButtonUp += AlertTone_MouseRightButtonUp;
-
-                ChannelsCanvas.Children.Add(alertTone);
-                _settingsManager.UpdateAlertTonePaths(alertFilePath);
-
-                AdjustCanvasHeight();
-            }
-        }
-
-        private void AlertTone_MouseRightButtonUp(object sender, MouseButtonEventArgs e)
-        {
-            if (!isEditMode) return;
-
-            if (sender is AlertTone alertTone)
-            {
-                double x = Canvas.GetLeft(alertTone);
-                double y = Canvas.GetTop(alertTone);
-                _settingsManager.UpdateAlertTonePosition(alertTone.AlertFilePath, x, y);
-
-                AdjustCanvasHeight();
-            }
-        }
-
-        private void AdjustCanvasHeight()
-        {
-            double maxBottom = 0;
-
-            foreach (UIElement child in ChannelsCanvas.Children)
-            {
-                double childBottom = Canvas.GetTop(child) + child.RenderSize.Height;
-                if (childBottom > maxBottom)
-                {
-                    maxBottom = childBottom;
-                }
-            }
-
-            ChannelsCanvas.Height = maxBottom + 150;
-        }
-
-        private void MainWindow_Loaded(object sender, RoutedEventArgs e)
-        {
-            if (!string.IsNullOrEmpty(_settingsManager.LastCodeplugPath) && File.Exists(_settingsManager.LastCodeplugPath))
-            {
-                LoadCodeplug(_settingsManager.LastCodeplugPath);
-            }
-            else
-            {
-                GenerateChannelWidgets();
-            }
-        }
-
-        private async void OnHoldTimerElapsed(object sender, ElapsedEventArgs e)
-        {
-            foreach (ChannelBox channel in _selectedChannelsManager.GetSelectedChannels())
-            {
-                if (channel.SystemName == PLAYBACKSYS || channel.ChannelName == PLAYBACKCHNAME || channel.DstId == PLAYBACKTG)
-                    continue;
-
-                Codeplug.System system = Codeplug.GetSystemForChannel(channel.ChannelName);
-                Codeplug.Channel cpgChannel = Codeplug.GetChannelByName(channel.ChannelName);
-
-                if (!system.IsDvm)
-                {
-
-                    IPeer handler = _webSocketManager.GetWebSocketHandler(system.Name);
-
-                    if (channel.HoldState && !channel.IsReceiving && !channel.PttState && !channel.PageState)
-                    {
-                        //Task.Factory.StartNew(async () =>
-                        //{
-                        Console.WriteLine("Sending channel hold beep");
-
-                        Dispatcher.Invoke(() => { channel.PttButton.Background = channel.redGradient; });
-
-                        GRP_VCH_REQ req = new GRP_VCH_REQ
-                        {
-                            SrcId = system.Rid,
-                            DstId = cpgChannel.Tgid,
-                            Site = system.Site
-                        };
-
-                        handler.SendMessage(req.GetData());
-
-                        await Task.Delay(1000);
-
-                        SendAlertTone("hold.wav", true);
-                        // });
-                    }
-                } else
-                {
-                    PeerSystem handler = _fneSystemManager.GetFneSystem(system.Name);
-
-                    if (channel.HoldState && !channel.IsReceiving && !channel.PttState && !channel.PageState)
-                    {
-                        handler.SendP25TDU(UInt32.Parse(system.Rid), UInt32.Parse(cpgChannel.Tgid), true);
-                        await Task.Delay(1000);
-
-                        SendAlertTone("hold.wav", true);
-                    }
-                }
-            }
-        }
-
-        protected override void OnClosing(System.ComponentModel.CancelEventArgs e)
-        {
-            _settingsManager.SaveSettings();
-            base.OnClosing(e);
-            Application.Current.Shutdown();
-        }
-
-        private void ClearEmergency_Click(object sender, RoutedEventArgs e)
-        {
-            _emergencyAlertPlayback.Stop();
-            _flashingManager.Stop();
-
-            foreach (ChannelBox channel in _selectedChannelsManager.GetSelectedChannels())
-            {
-                channel.Emergency = false;
-            }
-        }
-
-        private void btnAlert1_Click(object sender, RoutedEventArgs e)
-        {
-            Dispatcher.Invoke(() => {
-                SendAlertTone("alert1.wav");
-            });
-        }
-
-        private void btnAlert2_Click(object sender, RoutedEventArgs e)
-        {
-            Dispatcher.Invoke(() =>
-            {
-                SendAlertTone("alert2.wav");
-            });
-        }
-
-        private void btnAlert3_Click(object sender, RoutedEventArgs e)
-        {
-            Dispatcher.Invoke(() =>
-            {
-                SendAlertTone("alert3.wav");
-            });
-        }
-
-        private async void btnGlobalPtt_Click(object sender, RoutedEventArgs e)
-        {
-            if (globalPttState)
-                await Task.Delay(500);
-
-            globalPttState = !globalPttState;
-
-            foreach (ChannelBox channel in _selectedChannelsManager.GetSelectedChannels())
-            {
-                if (channel.SystemName == PLAYBACKSYS || channel.ChannelName == PLAYBACKCHNAME || channel.DstId == PLAYBACKTG)
-                    continue;
-
-                Codeplug.System system = Codeplug.GetSystemForChannel(channel.ChannelName);
-                Codeplug.Channel cpgChannel = Codeplug.GetChannelByName(channel.ChannelName);
-
-                if (!system.IsDvm)
-                {
-                    IPeer handler = _webSocketManager.GetWebSocketHandler(system.Name);
-
-                    if (!channel.IsSelected)
-                        continue;
-
-                    if (globalPttState)
-                    {
-                        Dispatcher.Invoke(() =>
-                        {
-                            btnGlobalPtt.Background = channel.redGradient;
-                        });
-
-
-                        GRP_VCH_REQ request = new GRP_VCH_REQ
-                        {
-                            SrcId = system.Rid,
-                            DstId = cpgChannel.Tgid,
-                            Site = system.Site
-                        };
-
-                        channel.PttState = true;
-
-                        handler.SendMessage(request.GetData());
-                    }
-                    else
-                    {
-                        Dispatcher.Invoke(() =>
-                        {
-                            btnGlobalPtt.Background = channel.grayGradient;
-                        });
-
-                        GRP_VCH_RLS release = new GRP_VCH_RLS
-                        {
-                            SrcId = system.Rid,
-                            DstId = cpgChannel.Tgid,
-                            Site = system.Site
-                        };
-
-                        channel.PttState = false;
-
-                        handler.SendMessage(release.GetData());
-                    }
-                } else
-                {
-                    PeerSystem handler = _fneSystemManager.GetFneSystem(system.Name);
-
-                    channel.txStreamId = handler.NewStreamId();
-
-                    if (globalPttState)
-                    {
-                        Dispatcher.Invoke(() =>
-                        {
-                            btnGlobalPtt.Background = channel.redGradient;
-                            channel.PttState = true;
-                        });
-
-                        handler.SendP25TDU(UInt32.Parse(system.Rid), UInt32.Parse(cpgChannel.Tgid), true);
-                    }
-                    else
-                    {
-                        Dispatcher.Invoke(() =>
-                        {
-                            btnGlobalPtt.Background = channel.grayGradient;
-                            channel.PttState = false;
-                        });
-
-                        handler.SendP25TDU(UInt32.Parse(system.Rid), UInt32.Parse(cpgChannel.Tgid), false);
-                    }
-                }
-            }
-        }
-
-        private void Button_Click(object sender, RoutedEventArgs e) { /* sub */ }
-
-        private void SelectAll_Click(object sender, RoutedEventArgs e)
-        {
-            foreach (ChannelBox channel in ChannelsCanvas.Children.OfType<ChannelBox>())
-            {
-                if (channel.SystemName == PLAYBACKSYS || channel.ChannelName == PLAYBACKCHNAME || channel.DstId == PLAYBACKTG)
-                    continue;
-
-                Codeplug.System system = Codeplug.GetSystemForChannel(channel.ChannelName);
-                Codeplug.Channel cpgChannel = Codeplug.GetChannelByName(channel.ChannelName);
-
-                if (!channel.IsSelected)
-                {
-                    channel.IsSelected = true;
-
-                    channel.Background = channel.IsSelected ? (Brush)new BrushConverter().ConvertFrom("#FF0B004B") : Brushes.Gray;
-
-                    if (channel.IsSelected)
-                    {
-                        _selectedChannelsManager.AddSelectedChannel(channel);
-                    }
-                    else
-                    {
-                        _selectedChannelsManager.RemoveSelectedChannel(channel);
-                    }
-                }
-            }
-        }
-
-        /// <summary>
-        /// Helper to encode and transmit PCM audio as P25 IMBE frames.
-        /// </summary>
-        private void P25EncodeAudioFrame(byte[] pcm, PeerSystem handler, ChannelBox channel, Codeplug.Channel cpgChannel, Codeplug.System system)
-        {
-            bool encryptCall = true; // TODO: make this dynamic somewhere?
-
-            if (channel.p25N > 17)
-                channel.p25N = 0;
-            if (channel.p25N == 0)
-                FneUtils.Memset(channel.netLDU1, 0, 9 * 25);
-            if (channel.p25N == 9)
-                FneUtils.Memset(channel.netLDU2, 0, 9 * 25);
-
-            // Log.Logger.Debug($"BYTE BUFFER {FneUtils.HexDump(pcm)}");
-
-            //// pre-process: apply gain to PCM audio frames
-            //if (Program.Configuration.TxAudioGain != 1.0f)
-            //{
-            //    BufferedWaveProvider buffer = new BufferedWaveProvider(waveFormat);
-            //    buffer.AddSamples(pcm, 0, pcm.Length);
-
-            //    VolumeWaveProvider16 gainControl = new VolumeWaveProvider16(buffer);
-            //    gainControl.Volume = Program.Configuration.TxAudioGain;
-            //    gainControl.Read(pcm, 0, pcm.Length);
-            //}
-
-            int smpIdx = 0;
-            short[] samples = new short[FneSystemBase.MBE_SAMPLES_LENGTH];
-            for (int pcmIdx = 0; pcmIdx < pcm.Length; pcmIdx += 2)
-            {
-                samples[smpIdx] = (short)((pcm[pcmIdx + 1] << 8) + pcm[pcmIdx + 0]);
-                smpIdx++;
-            }
-
-            // Convert to floats
-            float[] fSamples = AudioConverter.PcmToFloat(samples);
-
-            // Convert to signal
-            DiscreteSignal signal = new DiscreteSignal(8000, fSamples, true);
-
-            // Log.Logger.Debug($"SAMPLE BUFFER {FneUtils.HexDump(samples)}");
-
-            // encode PCM samples into IMBE codewords
-            byte[] imbe = new byte[FneSystemBase.IMBE_BUF_LEN];
-
-
-            int tone = 0;
-
-            if (true) // TODO: Disable/enable detection
-            {
-                tone = channel.toneDetector.Detect(signal);
-            }
-            if (tone > 0)
-            {
-                MBEToneGenerator.IMBEEncodeSingleTone((ushort)tone, imbe);
-                Console.WriteLine($"({system.Name}) P25D: {tone} HZ TONE DETECT");
-            }
-            else
-            {
-#if WIN32
-                if (channel.extFullRateVocoder == null)
-                    channel.extFullRateVocoder = new AmbeVocoder(true);
-
-                channel.extFullRateVocoder.encode(samples, out imbe);
-#else
-                if (channel.encoder == null)
-                    channel.encoder = new MBEEncoder(MBE_MODE.IMBE_88BIT);
-
-                channel.encoder.encode(samples, imbe);
-#endif
-            }
-            // Log.Logger.Debug($"IMBE {FneUtils.HexDump(imbe)}");
-
-            if (encryptCall && cpgChannel.GetAlgoId() != 0 && cpgChannel.GetKeyId() != 0)
-            {
-                // initial HDU MI
-                if (channel.p25N == 0)
-                {
-                    if (channel.mi.All(b => b == 0))
-                    {
-                        Random random = new Random();
-
-                        for (int i = 0; i < P25Defines.P25_MI_LENGTH; i++)
-                        {
-                            channel.mi[i] = (byte)random.Next(0x00, 0x100);
-                        }
-                    }
-
-                    channel.crypter.Prepare(cpgChannel.GetAlgoId(), cpgChannel.GetKeyId(), ProtocolType.P25Phase1, channel.mi);
-                }
-
-                // crypto time
-                channel.crypter.Process(imbe, channel.p25N < 9U ? P25Crypto.FrameType.LDU1 : P25Crypto.FrameType.LDU2, 0);
-
-                // last block of LDU2, prepare a new MI
-                if (channel.p25N == 17U)
-                {
-                    P25Crypto.CycleP25Lfsr(channel.mi);
-                    channel.crypter.Prepare(cpgChannel.GetAlgoId(), cpgChannel.GetKeyId(), ProtocolType.P25Phase1, channel.mi);
-                }
-            }
-
-            // fill the LDU buffers appropriately
-            switch (channel.p25N)
-            {
-                // LDU1
-                case 0:
-                    Buffer.BlockCopy(imbe, 0, channel.netLDU1, 10, FneSystemBase.IMBE_BUF_LEN);
-                    break;
-                case 1:
-                    Buffer.BlockCopy(imbe, 0, channel.netLDU1, 26, FneSystemBase.IMBE_BUF_LEN);
-                    break;
-                case 2:
-                    Buffer.BlockCopy(imbe, 0, channel.netLDU1, 55, FneSystemBase.IMBE_BUF_LEN);
-                    break;
-                case 3:
-                    Buffer.BlockCopy(imbe, 0, channel.netLDU1, 80, FneSystemBase.IMBE_BUF_LEN);
-                    break;
-                case 4:
-                    Buffer.BlockCopy(imbe, 0, channel.netLDU1, 105, FneSystemBase.IMBE_BUF_LEN);
-                    break;
-                case 5:
-                    Buffer.BlockCopy(imbe, 0, channel.netLDU1, 130, FneSystemBase.IMBE_BUF_LEN);
-                    break;
-                case 6:
-                    Buffer.BlockCopy(imbe, 0, channel.netLDU1, 155, FneSystemBase.IMBE_BUF_LEN);
-                    break;
-                case 7:
-                    Buffer.BlockCopy(imbe, 0, channel.netLDU1, 180, FneSystemBase.IMBE_BUF_LEN);
-                    break;
-                case 8:
-                    Buffer.BlockCopy(imbe, 0, channel.netLDU1, 204, FneSystemBase.IMBE_BUF_LEN);
-                    break;
-
-                // LDU2
-                case 9:
-                    Buffer.BlockCopy(imbe, 0, channel.netLDU2, 10, FneSystemBase.IMBE_BUF_LEN);
-                    break;
-                case 10:
-                    Buffer.BlockCopy(imbe, 0, channel.netLDU2, 26, FneSystemBase.IMBE_BUF_LEN);
-                    break;
-                case 11:
-                    Buffer.BlockCopy(imbe, 0, channel.netLDU2, 55, FneSystemBase.IMBE_BUF_LEN);
-                    break;
-                case 12:
-                    Buffer.BlockCopy(imbe, 0, channel.netLDU2, 80, FneSystemBase.IMBE_BUF_LEN);
-                    break;
-                case 13:
-                    Buffer.BlockCopy(imbe, 0, channel.netLDU2, 105, FneSystemBase.IMBE_BUF_LEN);
-                    break;
-                case 14:
-                    Buffer.BlockCopy(imbe, 0, channel.netLDU2, 130, FneSystemBase.IMBE_BUF_LEN);
-                    break;
-                case 15:
-                    Buffer.BlockCopy(imbe, 0, channel.netLDU2, 155, FneSystemBase.IMBE_BUF_LEN);
-                    break;
-                case 16:
-                    Buffer.BlockCopy(imbe, 0, channel.netLDU2, 180, FneSystemBase.IMBE_BUF_LEN);
-                    break;
-                case 17:
-                    Buffer.BlockCopy(imbe, 0, channel.netLDU2, 204, FneSystemBase.IMBE_BUF_LEN);
-                    break;
-            }
-
-            uint srcId = UInt32.Parse(system.Rid);
-            uint dstId = UInt32.Parse(cpgChannel.Tgid);
-
-            FnePeer peer = handler.peer;
-            RemoteCallData callData = new RemoteCallData()
-            {
-                SrcId = srcId,
-                DstId = dstId,
-                LCO = P25Defines.LC_GROUP
-            };
-
-            // send P25 LDU1
-            if (channel.p25N == 8U)
-            {
-                ushort pktSeq = 0;
-                if (channel.p25SeqNo == 0U)
-                    pktSeq = peer.pktSeq(true);
-                else
-                    pktSeq = peer.pktSeq();
-
-                //Console.WriteLine($"({channel.SystemName}) P25D: Traffic *VOICE FRAME    * PEER {handler.PeerId} SRC_ID {srcId} TGID {dstId} [STREAM ID {channel.txStreamId}]");
-
-                byte[] payload = new byte[200];
-                handler.CreateNewP25MessageHdr((byte)P25DUID.LDU1, callData, ref payload, cpgChannel.GetAlgoId(), cpgChannel.GetKeyId(), channel.mi);
-                handler.CreateP25LDU1Message(channel.netLDU1, ref payload, srcId, dstId);
-
-                peer.SendMaster(new Tuple<byte, byte>(Constants.NET_FUNC_PROTOCOL, Constants.NET_PROTOCOL_SUBFUNC_P25), payload, pktSeq, channel.txStreamId);
-            }
-
-            // send P25 LDU2
-            if (channel.p25N == 17U)
-            {
-                ushort pktSeq = 0;
-                if (channel.p25SeqNo == 0U)
-                    pktSeq = peer.pktSeq(true);
-                else
-                    pktSeq = peer.pktSeq();
-
-                //Console.WriteLine($"({channel.SystemName}) P25D: Traffic *VOICE FRAME    * PEER {handler.PeerId} SRC_ID {srcId} TGID {dstId} [STREAM ID {channel.txStreamId}]");
-
-                byte[] payload = new byte[200];
-                handler.CreateNewP25MessageHdr((byte)P25DUID.LDU2, callData, ref payload, cpgChannel.GetAlgoId(), cpgChannel.GetKeyId(), channel.mi);
-                handler.CreateP25LDU2Message(channel.netLDU2, ref payload, new CryptoParams { AlgId = cpgChannel.GetAlgoId(), KeyId = cpgChannel.GetKeyId(), Mi = channel.mi });
-
-                peer.SendMaster(new Tuple<byte, byte>(Constants.NET_FUNC_PROTOCOL, Constants.NET_PROTOCOL_SUBFUNC_P25), payload, pktSeq, channel.txStreamId);
-            }
-
-            channel.p25SeqNo++;
-            channel.p25N++;
-        }
-
-        /// <summary>
-        /// Helper to decode and playback P25 IMBE frames as PCM audio.
-        /// </summary>
-        /// <param name="ldu"></param>
-        /// <param name="e"></param>
-        private void P25DecodeAudioFrame(byte[] ldu, P25DataReceivedEvent e, PeerSystem system, ChannelBox channel, bool emergency = false, P25Crypto.FrameType frameType = P25Crypto.FrameType.LDU1)
-        {
-            try
-            {
-                // decode 9 IMBE codewords into PCM samples
-                for (int n = 0; n < 9; n++)
-                {
-                    byte[] imbe = new byte[FneSystemBase.IMBE_BUF_LEN];
-                    switch (n)
-                    {
-                        case 0:
-                            Buffer.BlockCopy(ldu, 10, imbe, 0, FneSystemBase.IMBE_BUF_LEN);
-                            break;
-                        case 1:
-                            Buffer.BlockCopy(ldu, 26, imbe, 0, FneSystemBase.IMBE_BUF_LEN);
-                            break;
-                        case 2:
-                            Buffer.BlockCopy(ldu, 55, imbe, 0, FneSystemBase.IMBE_BUF_LEN);
-                            break;
-                        case 3:
-                            Buffer.BlockCopy(ldu, 80, imbe, 0, FneSystemBase.IMBE_BUF_LEN);
-                            break;
-                        case 4:
-                            Buffer.BlockCopy(ldu, 105, imbe, 0, FneSystemBase.IMBE_BUF_LEN);
-                            break;
-                        case 5:
-                            Buffer.BlockCopy(ldu, 130, imbe, 0, FneSystemBase.IMBE_BUF_LEN);
-                            break;
-                        case 6:
-                            Buffer.BlockCopy(ldu, 155, imbe, 0, FneSystemBase.IMBE_BUF_LEN);
-                            break;
-                        case 7:
-                            Buffer.BlockCopy(ldu, 180, imbe, 0, FneSystemBase.IMBE_BUF_LEN);
-                            break;
-                        case 8:
-                            Buffer.BlockCopy(ldu, 204, imbe, 0, FneSystemBase.IMBE_BUF_LEN);
-                            break;
-                    }
-
-                    //Log.Logger.Debug($"Decoding IMBE buffer: {FneUtils.HexDump(imbe)}");
-
-                    short[] samples = new short[FneSystemBase.MBE_SAMPLES_LENGTH];
-
-                    channel.crypter.Process(imbe, frameType, n);
-
-#if WIN32
-                    if (channel.extFullRateVocoder == null)
-                        channel.extFullRateVocoder = new AmbeVocoder(true);
-
-                    channel.p25Errs = channel.extFullRateVocoder.decode(imbe, out samples);
-#else
-
-                    channel.p25Errs = channel.decoder.decode(imbe, samples);
-#endif
-
-                    if (emergency)
-                    {
-                        if (!channel.Emergency)
-                        {
-                            Task.Run(() =>
-                            {
-                                HandleEmergencyAlarmResponse(new EMRG_ALRM_RSP
-                                {
-                                    SrcId = e.SrcId.ToString(),
-                                    DstId = e.DstId.ToString()
-                                });
-                            });
-                        }
-                    }
-
-                    if (samples != null)
-                    {
-                        //Log.Logger.Debug($"({Config.Name}) P25D: Traffic *VOICE FRAME    * PEER {e.PeerId} SRC_ID {e.SrcId} TGID {e.DstId} VC{n} ERRS {errs} [STREAM ID {e.StreamId}]");
-                        //Log.Logger.Debug($"IMBE {FneUtils.HexDump(imbe)}");
-                        //Console.WriteLine($"SAMPLE BUFFER {FneUtils.HexDump(samples)}");
-
-                        int pcmIdx = 0;
-                        byte[] pcmData = new byte[samples.Length * 2];
-                        for (int i = 0; i < samples.Length; i++)
-                        {
-                            pcmData[pcmIdx] = (byte)(samples[i] & 0xFF);
-                            pcmData[pcmIdx + 1] = (byte)((samples[i] >> 8) & 0xFF);
-                            pcmIdx += 2;
-                        }
-
-                        _audioManager.AddTalkgroupStream(e.DstId.ToString(), pcmData);
-                    }
-                }
-            }
-            catch (Exception ex)
-            {
-                Console.WriteLine($"Audio Decode Exception: {ex.Message}");
-            }
-        }
-
-        private uint GetUniqueRid(string ridString)
-        {
-            uint rid;
-
-            // Try to parse the RID, default to 1000 if parsing fails
-            if (!UInt32.TryParse(ridString, out rid))
-            {
-                rid = 1000;
-            }
-
-            // Ensure uniqueness by incrementing if needed
-            while (usedRids.Contains(rid))
-            {
-                rid++;
-            }
-
-            // Store the new unique RID
-            usedRids.Add(rid);
-
-            return rid;
-        }
-
-        /// <summary>
-        /// 
-        /// </summary>
-        /// <param name="e"></param>
-        public void KeyResponseReceived(KeyResponseEvent e)
-        {
-            //Console.WriteLine($"Message ID: {e.KmmKey.MessageId}");
-            //Console.WriteLine($"Decrypt Info Format: {e.KmmKey.DecryptInfoFmt}");
-            //Console.WriteLine($"Algorithm ID: {e.KmmKey.AlgId}");
-            //Console.WriteLine($"Key ID: {e.KmmKey.KeyId}");
-            //Console.WriteLine($"Keyset ID: {e.KmmKey.KeysetItem.KeysetId}");
-            //Console.WriteLine($"Keyset Alg ID: {e.KmmKey.KeysetItem.AlgId}");
-            //Console.WriteLine($"Keyset Key Length: {e.KmmKey.KeysetItem.KeyLength}");
-            //Console.WriteLine($"Number of Keys: {e.KmmKey.KeysetItem.Keys.Count}");
-
-            foreach (var key in e.KmmKey.KeysetItem.Keys)
-            {
-                //Console.WriteLine($"  Key Format: {key.KeyFormat}");
-                //Console.WriteLine($"  SLN: {key.Sln}");
-                //Console.WriteLine($"  Key ID: {key.KeyId}");
-                //Console.WriteLine($"  Key Data: {BitConverter.ToString(key.GetKey())}");
-
-                Dispatcher.Invoke(() =>
-                {
-                    foreach (ChannelBox channel in _selectedChannelsManager.GetSelectedChannels())
-                    {
-                        Codeplug.System system = Codeplug.GetSystemForChannel(channel.ChannelName);
-                        Codeplug.Channel cpgChannel = Codeplug.GetChannelByName(channel.ChannelName);
-
-                        if (!system.IsDvm)
-                            continue;
-
-                        PeerSystem handler = _fneSystemManager.GetFneSystem(system.Name);
-
-                        if (cpgChannel.GetKeyId() != 0 && cpgChannel.GetAlgoId() != 0)
-                            channel.crypter.AddKey(key.KeyId, e.KmmKey.KeysetItem.AlgId, key.GetKey());
-                    }
-                });
-            }
-        }
-
-        private void KeyStatus_Click(object sender, RoutedEventArgs e)
-        {
-            KeyStatusWindow keyStatus = new KeyStatusWindow(Codeplug, this);
-            keyStatus.Show();
-        }
-
-        /// <summary>
-        /// Event handler used to process incoming P25 data.
-        /// </summary>
-        /// <param name="sender"></param>
-        /// <param name="e"></param>
-        public void P25DataReceived(P25DataReceivedEvent e, DateTime pktTime)
-        {
-            uint sysId = (uint)((e.Data[11U] << 8) | (e.Data[12U] << 0));
-            uint netId = FneUtils.Bytes3ToUInt32(e.Data, 16);
-            byte control = e.Data[14U];
-
-            byte len = e.Data[23];
-            byte[] data = new byte[len];
-            for (int i = 24; i < len; i++)
-                data[i - 24] = e.Data[i];
-
-            Dispatcher.Invoke(() =>
-            {
-                foreach (ChannelBox channel in _selectedChannelsManager.GetSelectedChannels())
-                {
-                    Codeplug.System system = Codeplug.GetSystemForChannel(channel.ChannelName);
-                    Codeplug.Channel cpgChannel = Codeplug.GetChannelByName(channel.ChannelName);
-
-                    bool isEmergency = false;
-                    bool encrypted = false;
-
-                    if (!system.IsDvm)
-                        continue;
-
-                    PeerSystem handler = _fneSystemManager.GetFneSystem(system.Name);
-
-                    if (!channel.IsEnabled)
-                        continue;
-
-                    if (cpgChannel.Tgid != e.DstId.ToString())
-                        continue;
-
-                    if (!systemStatuses.ContainsKey(cpgChannel.Name))
-                    {
-                        systemStatuses[cpgChannel.Name] = new SlotStatus();
-                    }
-
-                    if (channel.decoder == null)
-                    {
-                        channel.decoder = new MBEDecoder(MBE_MODE.IMBE_88BIT);
-                    }
-
-                    SlotStatus slot = systemStatuses[cpgChannel.Name];
-
-                    // if this is an LDU1 see if this is the first LDU with HDU encryption data
-                    if (e.DUID == P25DUID.LDU1)
-                    {
-                        byte frameType = e.Data[180];
-
-                        // get the initial MI and other enc info (bug found by the screeeeeeeeech on initial tx...)
-                        if (frameType == P25Defines.P25_FT_HDU_VALID)
-                        {
-                            channel.algId = e.Data[181];
-                            channel.kId = (ushort)((e.Data[182] << 8) | e.Data[183]);
-                            Array.Copy(e.Data, 184, channel.mi, 0, P25Defines.P25_MI_LENGTH);
-
-                            channel.crypter.Prepare(channel.algId, channel.kId, P25Crypto.ProtocolType.P25Phase1, channel.mi);
-
-                            encrypted = true;
-                        }
-                    }
-
-                    // is this a new call stream?
-                    if (e.StreamId != slot.RxStreamId && ((e.DUID != P25DUID.TDU) && (e.DUID != P25DUID.TDULC)))
-                    {
-                        channel.IsReceiving = true;
-                        slot.RxStart = pktTime;
-                        Console.WriteLine($"({system.Name}) P25D: Traffic *CALL START     * PEER {e.PeerId} SRC_ID {e.SrcId} TGID {e.DstId} [STREAM ID {e.StreamId}]");
-
-                        FneUtils.Memset(channel.mi, 0x00, P25Defines.P25_MI_LENGTH);
-
-                        callHistoryWindow.AddCall(cpgChannel.Name, (int)e.SrcId, (int)e.DstId);
-                        callHistoryWindow.ChannelKeyed(cpgChannel.Name, (int)e.SrcId, encrypted);
-
-                        string alias = string.Empty;
-
-                        try
-                        {
-                            alias = AliasTools.GetAliasByRid(system.RidAlias, (int)e.SrcId);
-                        }
-                        catch (Exception) { }
-
-                        if (alias.IsNullOrEmpty())
-                            channel.LastSrcId = "Last SRC: " + e.SrcId;
-                        else
-                            channel.LastSrcId = "Last: " + alias;
-
-                        if (channel.algId != P25Defines.P25_ALGO_UNENCRYPT)
-                            channel.Background = (Brush)new BrushConverter().ConvertFrom("#ffdeaf0a");
-                        else
-                            channel.Background = (Brush)new BrushConverter().ConvertFrom("#FF00BC48");
-                    }
-
-                    // Is the call over?
-                    if (((e.DUID == P25DUID.TDU) || (e.DUID == P25DUID.TDULC)) && (slot.RxType != fnecore.FrameType.TERMINATOR))
-                    {
-                        channel.IsReceiving = false;
-                        TimeSpan callDuration = pktTime - slot.RxStart;
-                        Console.WriteLine($"({system.Name}) P25D: Traffic *CALL END       * PEER {e.PeerId} SRC_ID {e.SrcId} TGID {e.DstId} DUR {callDuration} [STREAM ID {e.StreamId}]");
-                        channel.Background = (Brush)new BrushConverter().ConvertFrom("#FF0B004B");
-                        callHistoryWindow.ChannelUnkeyed(cpgChannel.Name, (int)e.SrcId);
-                        return;
-                    }
-
-                    if ((channel.algId != cpgChannel.GetAlgoId() || channel.kId != cpgChannel.GetKeyId()) && channel.algId != P25Defines.P25_ALGO_UNENCRYPT)
-                        continue;
-
-                    byte[] newMI = new byte[P25Defines.P25_MI_LENGTH];
-
-                    int count = 0;
-
-                    switch (e.DUID)
-                    {
-                        case P25DUID.LDU1:
-                            {
-                                // The '62', '63', '64', '65', '66', '67', '68', '69', '6A' records are LDU1
-                                if ((data[0U] == 0x62U) && (data[22U] == 0x63U) &&
-                                    (data[36U] == 0x64U) && (data[53U] == 0x65U) &&
-                                    (data[70U] == 0x66U) && (data[87U] == 0x67U) &&
-                                    (data[104U] == 0x68U) && (data[121U] == 0x69U) &&
-                                    (data[138U] == 0x6AU))
-                                {
-                                    // The '62' record - IMBE Voice 1
-                                    Buffer.BlockCopy(data, count, channel.netLDU1, 0, 22);
-                                    count += 22;
-
-                                    // The '63' record - IMBE Voice 2
-                                    Buffer.BlockCopy(data, count, channel.netLDU1, 25, 14);
-                                    count += 14;
-
-                                    // The '64' record - IMBE Voice 3 + Link Control
-                                    Buffer.BlockCopy(data, count, channel.netLDU1, 50, 17);
-                                    byte serviceOptions = data[count + 3];
-                                    isEmergency = (serviceOptions & 0x80) == 0x80;
-                                    count += 17;
-
-                                    // The '65' record - IMBE Voice 4 + Link Control
-                                    Buffer.BlockCopy(data, count, channel.netLDU1, 75, 17);
-                                    count += 17;
-
-                                    // The '66' record - IMBE Voice 5 + Link Control
-                                    Buffer.BlockCopy(data, count, channel.netLDU1, 100, 17);
-                                    count += 17;
-
-                                    // The '67' record - IMBE Voice 6 + Link Control
-                                    Buffer.BlockCopy(data, count, channel.netLDU1, 125, 17);
-                                    count += 17;
-
-                                    // The '68' record - IMBE Voice 7 + Link Control
-                                    Buffer.BlockCopy(data, count, channel.netLDU1, 150, 17);
-                                    count += 17;
-
-                                    // The '69' record - IMBE Voice 8 + Link Control
-                                    Buffer.BlockCopy(data, count, channel.netLDU1, 175, 17);
-                                    count += 17;
-
-                                    // The '6A' record - IMBE Voice 9 + Low Speed Data
-                                    Buffer.BlockCopy(data, count, channel.netLDU1, 200, 16);
-                                    count += 16;
-
-                                    // decode 9 IMBE codewords into PCM samples
-                                    P25DecodeAudioFrame(channel.netLDU1, e, handler, channel, isEmergency);
-                                }
-                            }
-                            break;
-                        case P25DUID.LDU2:
-                            {
-                                // The '6B', '6C', '6D', '6E', '6F', '70', '71', '72', '73' records are LDU2
-                                if ((data[0U] == 0x6BU) && (data[22U] == 0x6CU) &&
-                                    (data[36U] == 0x6DU) && (data[53U] == 0x6EU) &&
-                                    (data[70U] == 0x6FU) && (data[87U] == 0x70U) &&
-                                    (data[104U] == 0x71U) && (data[121U] == 0x72U) &&
-                                    (data[138U] == 0x73U))
-                                {
-                                    // The '6B' record - IMBE Voice 10
-                                    Buffer.BlockCopy(data, count, channel.netLDU2, 0, 22);
-                                    count += 22;
-
-                                    // The '6C' record - IMBE Voice 11
-                                    Buffer.BlockCopy(data, count, channel.netLDU2, 25, 14);
-                                    count += 14;
-
-                                    // The '6D' record - IMBE Voice 12 + Encryption Sync
-                                    Buffer.BlockCopy(data, count, channel.netLDU2, 50, 17);
-                                    newMI[0] = data[count + 1];
-                                    newMI[1] = data[count + 2];
-                                    newMI[2] = data[count + 3];
-                                    count += 17;
-
-                                    // The '6E' record - IMBE Voice 13 + Encryption Sync
-                                    Buffer.BlockCopy(data, count, channel.netLDU2, 75, 17);
-                                    newMI[3] = data[count + 1];
-                                    newMI[4] = data[count + 2];
-                                    newMI[5] = data[count + 3];
-                                    count += 17;
-
-                                    // The '6F' record - IMBE Voice 14 + Encryption Sync
-                                    Buffer.BlockCopy(data, count, channel.netLDU2, 100, 17);
-                                    newMI[6] = data[count + 1];
-                                    newMI[7] = data[count + 2];
-                                    newMI[8] = data[count + 3];
-                                    count += 17;
-
-                                    // The '70' record - IMBE Voice 15 + Encryption Sync
-                                    Buffer.BlockCopy(data, count, channel.netLDU2, 125, 17);
-                                    channel.algId = data[count + 1];                                    // Algorithm ID
-                                    channel.kId = (ushort)((data[count + 2] << 8) | data[count + 3]);   // Key ID
-                                    count += 17;
-
-                                    // The '71' record - IMBE Voice 16 + Encryption Sync
-                                    Buffer.BlockCopy(data, count, channel.netLDU2, 150, 17);
-                                    count += 17;
-
-                                    // The '72' record - IMBE Voice 17 + Encryption Sync
-                                    Buffer.BlockCopy(data, count, channel.netLDU2, 175, 17);
-                                    count += 17;
-
-                                    // The '73' record - IMBE Voice 18 + Low Speed Data
-                                    Buffer.BlockCopy(data, count, channel.netLDU2, 200, 16);
-                                    count += 16;
-
-                                    if (channel.p25Errs > 0) // temp, need to actually get errors I guess
-                                        P25Crypto.CycleP25Lfsr(channel.mi);
-                                    else
-                                        Array.Copy(newMI, channel.mi, P25Defines.P25_MI_LENGTH);
-
-                                    // decode 9 IMBE codewords into PCM samples
-                                    P25DecodeAudioFrame(channel.netLDU2, e, handler, channel, isEmergency, P25Crypto.FrameType.LDU2);
-                                }
-                            }
-                            break;
-                    }
-
-                    if (channel.mi != null)
-                        channel.crypter.Prepare(channel.algId, channel.kId, P25Crypto.ProtocolType.P25Phase1, channel.mi);
-
-                    slot.RxRFS = e.SrcId;
-                    slot.RxType = e.FrameType;
-                    slot.RxTGId = e.DstId;
-                    slot.RxTime = pktTime;
-                    slot.RxStreamId = e.StreamId;
-
-                }
-            });
-        }
-
-        private void CallHist_Click(object sender, RoutedEventArgs e)
-        {
-            callHistoryWindow.Show();
-        }
-    }
-}
+/*
+* WhackerLink - WhackerLinkConsoleV2
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program.  If not, see <http://www.gnu.org/licenses/>.
+* 
+* Copyright (C) 2024-2025 Caleb, K4PHP
+* Copyright (C) 2025 J. Dean
+* 
+*/
+
+using Microsoft.Win32;
+using System;
+using System.Timers;
+using System.IO;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Input;
+using WhackerLinkLib.Models.Radio;
+using YamlDotNet.Serialization;
+using YamlDotNet.Serialization.NamingConventions;
+using WhackerLinkConsoleV2.Controls;
+using WebSocketManager = WhackerLinkLib.Managers.WebSocketManager;
+using System.Windows.Media;
+using WhackerLinkLib.Utils;
+using WhackerLinkLib.Models;
+using System.Net;
+using NAudio.Wave;
+using WhackerLinkLib.Interfaces;
+using WhackerLinkLib.Models.IOSP;
+using fnecore.P25;
+using fnecore;
+using Microsoft.VisualBasic;
+using System.Text;
+using Constants = fnecore.Constants;
+using System.Security.Cryptography;
+using fnecore.P25.LC.TSBK;
+using WebSocketSharp;
+using NWaves.Signals;
+using static WhackerLinkConsoleV2.P25Crypto;
+using static WhackerLinkLib.Models.Radio.Codeplug;
+
+namespace WhackerLinkConsoleV2
+{
+    public partial class MainWindow : Window
+    {
+        public Codeplug Codeplug { get; set; }
+        private bool isEditMode = false;
+
+        private bool globalPttState = false;
+
+        private UIElement _draggedElement;
+        private Point _startPoint;
+        private double _offsetX;
+        private double _offsetY;
+        private bool _isDragging;
+
+        private SettingsManager _settingsManager = new SettingsManager();
+        private SelectedChannelsManager _selectedChannelsManager;
+        private FlashingBackgroundManager _flashingManager;
+        private WaveFilePlaybackManager _emergencyAlertPlayback;
+        private WebSocketManager _webSocketManager = new WebSocketManager();
+
+        private ChannelBox playbackChannelBox;
+
+        CallHistoryWindow callHistoryWindow = new CallHistoryWindow();
+
+        public static string PLAYBACKTG = "LOCPLAYBACK";
+        public static string PLAYBACKSYS = "LOCPLAYBACKSYS";
+        public static string PLAYBACKCHNAME = "PLAYBACK";
+
+        private readonly WaveInEvent _waveIn;
+        private readonly AudioManager _audioManager;
+
+        private static System.Timers.Timer _channelHoldTimer;
+
+        private Dictionary<string, SlotStatus> systemStatuses = new Dictionary<string, SlotStatus>();
+        private FneSystemManager _fneSystemManager = new FneSystemManager();
+
+        private bool cryptodev = true;
+
+        private static HashSet<uint> usedRids = new HashSet<uint>();
+
+        List<Tuple<uint, uint>> fneAffs = new List<Tuple<uint, uint>>();
+
+        public MainWindow()
+        {
+            // Check command-line arguments for console flag
+            var args = Environment.GetCommandLineArgs();
+            bool showConsole = args.Any(arg => arg.Equals("--console", StringComparison.OrdinalIgnoreCase) || 
+                                               arg.Equals("-console", StringComparison.OrdinalIgnoreCase) ||
+                                               arg.Equals("/console", StringComparison.OrdinalIgnoreCase));
+
+#if DEBUG
+            showConsole = true; // Always show console in debug builds
+#endif
+
+            if (showConsole)
+            {
+                ConsoleNative.ShowConsole();
+            }
+
+            InitializeComponent();
+            _settingsManager.LoadSettings();
+            _selectedChannelsManager = new SelectedChannelsManager();
+            _flashingManager = new FlashingBackgroundManager(null, ChannelsCanvas, null, this);
+            _emergencyAlertPlayback = new WaveFilePlaybackManager(System.IO.Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "emergency.wav"));
+
+            _channelHoldTimer = new System.Timers.Timer(10000);
+            _channelHoldTimer.Elapsed += OnHoldTimerElapsed;
+            _channelHoldTimer.AutoReset = true;
+            _channelHoldTimer.Enabled = true;
+
+            _waveIn = new WaveInEvent
+            {
+                WaveFormat = new WaveFormat(8000, 16, 1)
+            };
+            _waveIn.DataAvailable += WaveIn_DataAvailable;
+            _waveIn.RecordingStopped += WaveIn_RecordingStopped;
+
+            _waveIn.StartRecording();
+
+            _audioManager = new AudioManager(_settingsManager);
+
+            _selectedChannelsManager.SelectedChannelsChanged += SelectedChannelsChanged;
+            Loaded += MainWindow_Loaded;
+        }
+
+        private void OpenCodeplug_Click(object sender, RoutedEventArgs e)
+        {
+            OpenFileDialog openFileDialog = new OpenFileDialog
+            {
+                Filter = "Codeplug Files (*.yml)|*.yml|All Files (*.*)|*.*",
+                Title = "Open Codeplug"
+            };
+            if (openFileDialog.ShowDialog() == true)
+            {
+                LoadCodeplug(openFileDialog.FileName);
+
+                _settingsManager.LastCodeplugPath = openFileDialog.FileName;
+                _settingsManager.SaveSettings();
+            }
+        }
+
+        private void ResetSettings_Click(object sender, RoutedEventArgs e)
+        {
+            if (File.Exists("UserSettings.json"))
+                File.Delete("UserSettings.json");
+        }
+
+        private void LoadCodeplug(string filePath)
+        {
+            try
+            {
+                var deserializer = new DeserializerBuilder()
+                    .WithNamingConvention(CamelCaseNamingConvention.Instance)
+                    .IgnoreUnmatchedProperties()
+                    .Build();
+
+                var yaml = File.ReadAllText(filePath);
+                Codeplug = deserializer.Deserialize<Codeplug>(yaml);
+
+                GenerateChannelWidgets();
+            }
+            catch (Exception ex)
+            {
+                MessageBox.Show($"Error loading codeplug: {ex.Message}", "Error", MessageBoxButton.OK, MessageBoxImage.Error);
+            }
+        }
+
+        private void GenerateChannelWidgets()
+        {
+            ChannelsCanvas.Children.Clear();
+            double offsetX = 20;
+            double offsetY = 20;
+
+            if (Codeplug != null)
+            {
+                foreach (var system in Codeplug.Systems)
+                {
+                    var systemStatusBox = new SystemStatusBox(system.Name, system.Address, system.Port);
+
+                    if (_settingsManager.SystemStatusPositions.TryGetValue(system.Name, out var position))
+                    {
+                        Canvas.SetLeft(systemStatusBox, position.X);
+                        Canvas.SetTop(systemStatusBox, position.Y);
+                    }
+                    else
+                    {
+                        Canvas.SetLeft(systemStatusBox, offsetX);
+                        Canvas.SetTop(systemStatusBox, offsetY);
+                    }
+
+                    systemStatusBox.MouseLeftButtonDown += SystemStatusBox_MouseLeftButtonDown;
+                    systemStatusBox.MouseMove += SystemStatusBox_MouseMove;
+                    systemStatusBox.MouseRightButtonDown += SystemStatusBox_MouseRightButtonDown;
+
+                    ChannelsCanvas.Children.Add(systemStatusBox);
+
+                    offsetX += 225;
+                    if (offsetX + 220 > ChannelsCanvas.ActualWidth)
+                    {
+                        offsetX = 20;
+                        offsetY += 106;
+                    }
+
+                    if (File.Exists(system.AliasPath))
+                        system.RidAlias = AliasTools.LoadAliases(system.AliasPath);
+
+                    if (!system.IsDvm)
+                    {
+                        _webSocketManager.AddWebSocketHandler(system.Name);
+
+                        IPeer handler = _webSocketManager.GetWebSocketHandler(system.Name);
+                        handler.OnVoiceChannelResponse += HandleVoiceResponse;
+                        handler.OnVoiceChannelRelease += HandleVoiceRelease;
+                        handler.OnEmergencyAlarmResponse += HandleEmergencyAlarmResponse;
+                        handler.OnAudioData += HandleReceivedAudio;
+                        handler.OnAffiliationUpdate += HandleAffiliationUpdate;
+                        handler.OnCallAlert += HandleCallAlert;
+
+                        handler.OnUnitRegistrationResponse += (response) =>
+                        {
+                            Dispatcher.Invoke(() =>
+                            {
+                                if (response.Status == (int)ResponseType.GRANT)
+                                {
+                                    systemStatusBox.Background = (Brush)new BrushConverter().ConvertFrom("#FF00BC48");
+                                    systemStatusBox.ConnectionState = "Connected";
+
+                                    foreach (ChannelBox channel in _selectedChannelsManager.GetSelectedChannels())
+                                    {
+                                        if (channel.SystemName == PLAYBACKSYS || channel.ChannelName == PLAYBACKCHNAME || channel.DstId == PLAYBACKTG)
+                                            continue;
+
+                                        Codeplug.System system = Codeplug.GetSystemForChannel(channel.ChannelName);
+                                        Codeplug.Channel cpgChannel = Codeplug.GetChannelByName(channel.ChannelName);
+
+                                        if (!system.IsDvm)
+                                        {
+                                            IPeer handler = _webSocketManager.GetWebSocketHandler(system.Name);
+
+                                            if (channel.IsSelected && handler.IsConnected)
+                                            {
+                                                Console.WriteLine("sending WLINK master aff");
+
+                                                Task.Run(() =>
+                                                {
+                                                    GRP_AFF_REQ release = new GRP_AFF_REQ
+                                                    {
+                                                        SrcId = system.Rid,
+                                                        DstId = cpgChannel.Tgid,
+                                                        Site = system.Site
+                                                    };
+
+                                                    handler.SendMessage(release.GetData());
+                                                });
+                                            }
+                                        }
+                                    }
+                                }
+                                else
+                                {
+                                    systemStatusBox.Background = new SolidColorBrush(Colors.Red);
+                                    systemStatusBox.ConnectionState = "Disconnected";
+                                }
+                            });
+                        };
+
+                        handler.OnClose += () =>
+                        {
+                            Dispatcher.Invoke(() =>
+                            {
+                                systemStatusBox.Background = new SolidColorBrush(Colors.Red);
+                                systemStatusBox.ConnectionState = "Disconnected";
+                            });
+                        };
+
+                        handler.OnOpen += () =>
+                        {
+                            Console.WriteLine("Peer connected");
+                            U_REG_REQ release = new U_REG_REQ
+                            {
+                                SrcId = system.Rid,
+                                Site = system.Site
+                            };
+
+                            handler.SendMessage(release.GetData());
+                        };
+
+                        handler.OnReconnecting += () =>
+                        {
+                            Console.WriteLine("Peer reconnecting");
+                        };
+
+                        Task.Run(() =>
+                        {
+                            handler.Connect(system.Address, system.Port, system.AuthKey);
+
+                            handler.OnGroupAffiliationResponse += (response) => { /* TODO */ };
+
+                            if (!handler.IsConnected)
+                            {
+                                systemStatusBox.Background = new SolidColorBrush(Colors.Red);
+                                systemStatusBox.ConnectionState = "Disconnected";
+                            }
+                        });
+                    } else
+                    {
+                        _fneSystemManager.AddFneSystem(system.Name, system, this);
+
+                        PeerSystem peer = _fneSystemManager.GetFneSystem(system.Name);
+
+                        peer.peer.PeerConnected += (sender, response) =>
+                        {
+                            Console.WriteLine("FNE Peer connected");
+
+                            Dispatcher.Invoke(() =>
+                            {
+                                systemStatusBox.Background = (Brush)new BrushConverter().ConvertFrom("#FF00BC48");
+                                systemStatusBox.ConnectionState = "Connected";
+                            });
+                        };
+
+
+                        peer.peer.PeerDisconnected += (response) =>
+                        {
+                            Console.WriteLine("FNE Peer disconnected");
+
+                            Dispatcher.Invoke(() =>
+                            {
+                                systemStatusBox.Background = new SolidColorBrush(Colors.Red);
+                                systemStatusBox.ConnectionState = "Disconnected";
+                            });
+                        };
+
+                        Task.Run(() =>
+                        {
+                            peer.Start();
+                        });
+                    }
+
+                    if (!_settingsManager.ShowSystemStatus)
+                        systemStatusBox.Visibility = Visibility.Collapsed;
+
+                }
+            }
+
+            if (_settingsManager.ShowChannels && Codeplug != null)
+            {
+                foreach (var zone in Codeplug.Zones)
+                {
+                    foreach (var channel in zone.Channels)
+                    {
+                        var channelBox = new ChannelBox(_selectedChannelsManager, _audioManager, channel.Name, channel.System, channel.Tgid);
+
+                        //channelBox.crypter.AddKey(channel.GetKeyId(), channel.GetAlgoId(), channel.GetEncryptionKey());
+
+                        systemStatuses.Add(channel.Name, new SlotStatus());
+
+                        if (_settingsManager.ChannelPositions.TryGetValue(channel.Name, out var position))
+                        {
+                            Canvas.SetLeft(channelBox, position.X);
+                            Canvas.SetTop(channelBox, position.Y);
+                        }
+                        else
+                        {
+                            Canvas.SetLeft(channelBox, offsetX);
+                            Canvas.SetTop(channelBox, offsetY);
+                        }
+
+                        channelBox.PTTButtonClicked += ChannelBox_PTTButtonClicked;
+                        channelBox.PageButtonClicked += ChannelBox_PageButtonClicked;
+                        channelBox.HoldChannelButtonClicked += ChannelBox_HoldChannelButtonClicked;
+
+                        channelBox.MouseLeftButtonDown += ChannelBox_MouseLeftButtonDown;
+                        channelBox.MouseMove += ChannelBox_MouseMove;
+                        channelBox.MouseRightButtonDown += ChannelBox_MouseRightButtonDown;
+                        ChannelsCanvas.Children.Add(channelBox);
+
+                        offsetX += 225;
+
+                        if (offsetX + 220 > ChannelsCanvas.ActualWidth)
+                        {
+                            offsetX = 20;
+                            offsetY += 106;
+                        }
+                    }
+                }
+            }
+
+            if (_settingsManager.ShowAlertTones && Codeplug != null)
+            {
+                foreach (var alertPath in _settingsManager.AlertToneFilePaths)
+                {
+                    var alertTone = new AlertTone(alertPath)
+                    {
+                        IsEditMode = isEditMode
+                    };
+
+                    alertTone.OnAlertTone += SendAlertTone;
+
+                    if (_settingsManager.AlertTonePositions.TryGetValue(alertPath, out var position))
+                    {
+                        Canvas.SetLeft(alertTone, position.X);
+                        Canvas.SetTop(alertTone, position.Y);
+                    }
+                    else
+                    {
+                        Canvas.SetLeft(alertTone, 20);
+                        Canvas.SetTop(alertTone, 20);
+                    }
+
+                    alertTone.MouseRightButtonUp += AlertTone_MouseRightButtonUp;
+
+                    ChannelsCanvas.Children.Add(alertTone);
+                }
+            }
+
+            playbackChannelBox = new ChannelBox(_selectedChannelsManager, _audioManager, PLAYBACKCHNAME, PLAYBACKSYS, PLAYBACKTG);
+
+            if (_settingsManager.ChannelPositions.TryGetValue(PLAYBACKCHNAME, out var pos))
+            {
+                Canvas.SetLeft(playbackChannelBox, pos.X);
+                Canvas.SetTop(playbackChannelBox, pos.Y);
+            }
+            else
+            {
+                Canvas.SetLeft(playbackChannelBox, offsetX);
+                Canvas.SetTop(playbackChannelBox, offsetY);
+            }
+
+            playbackChannelBox.PTTButtonClicked += ChannelBox_PTTButtonClicked;
+            playbackChannelBox.PageButtonClicked += ChannelBox_PageButtonClicked;
+            playbackChannelBox.HoldChannelButtonClicked += ChannelBox_HoldChannelButtonClicked;
+
+            playbackChannelBox.MouseLeftButtonDown += ChannelBox_MouseLeftButtonDown;
+            playbackChannelBox.MouseMove += ChannelBox_MouseMove;
+            playbackChannelBox.MouseRightButtonDown += ChannelBox_MouseRightButtonDown;
+            ChannelsCanvas.Children.Add(playbackChannelBox);
+
+            //offsetX += 225;
+
+            //if (offsetX + 220 > ChannelsCanvas.ActualWidth)
+            //{
+            //    offsetX = 20;
+            //    offsetY += 106;
+            //}
+
+            AdjustCanvasHeight();
+        }
+
+        private void WaveIn_RecordingStopped(object sender, EventArgs e)
+        {
+            /* stub */
+        }
+
+        private void WaveIn_DataAvailable(object sender, WaveInEventArgs e)
+        {
+            bool isAnyTgOn = false;
+
+            foreach (ChannelBox channel in _selectedChannelsManager.GetSelectedChannels())
+            {
+                if (channel.SystemName == PLAYBACKSYS || channel.ChannelName == PLAYBACKCHNAME || channel.DstId == PLAYBACKTG)
+                {
+                    playbackChannelBox.IsReceiving = true;
+                    continue;
+                }
+
+                Codeplug.System system = Codeplug.GetSystemForChannel(channel.ChannelName);
+                Codeplug.Channel cpgChannel = Codeplug.GetChannelByName(channel.ChannelName);
+
+                Task.Run(() =>
+                {
+
+                    if (!system.IsDvm)
+                    {
+                        IPeer handler = _webSocketManager.GetWebSocketHandler(system.Name);
+
+                        if (channel.IsSelected && channel.VoiceChannel != null && channel.PttState)
+                        {
+                            isAnyTgOn = true;
+
+                            object voicePaket = new
+                            {
+                                type = PacketType.AUDIO_DATA,
+                                data = new
+                                {
+                                    Data = e.Buffer,
+                                    VoiceChannel = new VoiceChannel
+                                    {
+                                        Frequency = channel.VoiceChannel,
+                                        DstId = cpgChannel.Tgid,
+                                        SrcId = system.Rid,
+                                        Site = system.Site
+                                    },
+                                    Site = system.Site
+                                }
+                            };
+
+#if DEBUG
+                            Console.WriteLine($"WLINK AUDIO_DATA SrcId: {system.Rid}; DstId: {cpgChannel.Tgid}; Freq: {channel.VoiceChannel}");
+#endif
+
+                            handler.SendMessage(voicePaket);
+                        }
+                    }
+                    else
+                    {
+                        PeerSystem handler = _fneSystemManager.GetFneSystem(system.Name);
+
+                        if (channel.IsSelected && channel.PttState)
+                        {
+                            isAnyTgOn = true;
+
+                            int samples = 320;
+
+                            channel.chunkedPcm = AudioConverter.SplitToChunks(e.Buffer);
+
+                            foreach (byte[] chunk in channel.chunkedPcm)
+                            {
+                                if (chunk.Length == samples)
+                                {
+                                    P25EncodeAudioFrame(chunk, handler, channel, cpgChannel, system);
+                                }
+                                else
+                                {
+                                    Console.WriteLine("bad sample length: " + chunk.Length);
+                                }
+                            }
+                        }
+                    }
+                });
+            }
+
+            if (isAnyTgOn && playbackChannelBox.IsSelected)
+                _audioManager.AddTalkgroupStream(PLAYBACKTG, e.Buffer);
+        }
+
+        private void SelectedChannelsChanged()
+        {
+            foreach (ChannelBox channel in _selectedChannelsManager.GetSelectedChannels())
+            {
+                if (channel.SystemName == PLAYBACKSYS || channel.ChannelName == PLAYBACKCHNAME || channel.DstId == PLAYBACKTG)
+                    continue;
+
+                Codeplug.System system = Codeplug.GetSystemForChannel(channel.ChannelName);
+                Codeplug.Channel cpgChannel = Codeplug.GetChannelByName(channel.ChannelName);
+         
+                if (!system.IsDvm) {
+                    IPeer handler = _webSocketManager.GetWebSocketHandler(system.Name);
+
+                    if (channel.IsSelected && handler.IsConnected)
+                    {
+                        Console.WriteLine("sending WLINK master aff");
+
+                        Task.Run(() =>
+                        {
+                            GRP_AFF_REQ release = new GRP_AFF_REQ
+                            {
+                                SrcId = system.Rid,
+                                DstId = cpgChannel.Tgid,
+                                Site = system.Site
+                            };
+
+                            handler.SendMessage(release.GetData());
+                        });
+                    }
+                } else
+                {
+                    PeerSystem fne = _fneSystemManager.GetFneSystem(system.Name);
+
+                    if (channel.IsSelected)
+                    {
+                        uint newTgid = UInt32.Parse(cpgChannel.Tgid);
+                        bool exists = fneAffs.Any(aff => aff.Item2 == newTgid);
+
+                        if (cpgChannel.GetAlgoId() != 0 && cpgChannel.GetKeyId() != 0)
+                            fne.peer.SendMasterKeyRequest(cpgChannel.GetAlgoId(), cpgChannel.GetKeyId());
+
+                        if (!exists)
+                            fneAffs.Add(new Tuple<uint, uint>(GetUniqueRid(system.Rid), newTgid));
+
+                        //Console.WriteLine("FNE Affiliations:");
+                        //foreach (var aff in fneAffs)
+                        //{
+                        //    Console.WriteLine($"  RID: {aff.Item1}, TGID: {aff.Item2}");
+                        //}
+                    }
+                }
+            }
+
+            foreach (Codeplug.System system in Codeplug.Systems)
+            {
+                if (system.IsDvm)
+                {
+                    PeerSystem fne = _fneSystemManager.GetFneSystem(system.Name);
+                    //fne.peer.SendMasterAffiliationUpdate(fneAffs);
+                }
+            }
+        }
+
+        private void AudioSettings_Click(object sender, RoutedEventArgs e)
+        {
+            List<Codeplug.Channel> channels = Codeplug?.Zones.SelectMany(z => z.Channels).ToList() ?? new List<Codeplug.Channel>();
+
+            AudioSettingsWindow audioSettingsWindow = new AudioSettingsWindow(_settingsManager, _audioManager, channels);
+            audioSettingsWindow.ShowDialog();
+        }
+
+        private void P25Page_Click(object sender, RoutedEventArgs e)
+        {
+            DigitalPageWindow pageWindow = new DigitalPageWindow(Codeplug.Systems);
+            pageWindow.Owner = this;
+            if (pageWindow.ShowDialog() == true)
+            {
+                if (!pageWindow.RadioSystem.IsDvm)
+                {
+                    IPeer handler = _webSocketManager.GetWebSocketHandler(pageWindow.RadioSystem.Name);
+
+                    CALL_ALRT_REQ callAlert = new CALL_ALRT_REQ
+                    {
+                        SrcId = pageWindow.RadioSystem.Rid,
+                        DstId = pageWindow.DstId
+                    };
+
+                    handler.SendMessage(callAlert.GetData());
+                }
+                else
+                {
+                    PeerSystem handler = _fneSystemManager.GetFneSystem(pageWindow.RadioSystem.Name);
+                    IOSP_CALL_ALRT callAlert = new IOSP_CALL_ALRT(UInt32.Parse(pageWindow.DstId), UInt32.Parse(pageWindow.RadioSystem.Rid));
+
+                    RemoteCallData callData = new RemoteCallData
+                    {
+                        SrcId = UInt32.Parse(pageWindow.RadioSystem.Rid),
+                        DstId = UInt32.Parse(pageWindow.DstId),
+                        LCO = P25Defines.TSBK_IOSP_CALL_ALRT
+                    };
+
+                    byte[] tsbk = new byte[P25Defines.P25_TSBK_LENGTH_BYTES];
+
+                    callAlert.Encode(ref tsbk, true, true);
+
+                    handler.SendP25TSBK(callData, tsbk);
+
+                    Console.WriteLine("sent page");
+                }
+            }
+        }
+
+        private async void ManualPage_Click(object sender, RoutedEventArgs e)
+        {
+            QuickCallPage pageWindow = new QuickCallPage();
+            pageWindow.Owner = this;
+            if (pageWindow.ShowDialog() == true)
+            {
+                foreach (ChannelBox channel in _selectedChannelsManager.GetSelectedChannels())
+                {
+                    Codeplug.System system = Codeplug.GetSystemForChannel(channel.ChannelName);
+                    Codeplug.Channel cpgChannel = Codeplug.GetChannelByName(channel.ChannelName);
+
+                    if (channel.PageState)
+                    {
+                        ToneGenerator generator = new ToneGenerator();
+
+                        double toneADuration = 1.0;
+                        double toneBDuration = 3.0;
+
+                        byte[] toneA = generator.GenerateTone(Double.Parse(pageWindow.ToneA), toneADuration);
+                        byte[] toneB = generator.GenerateTone(Double.Parse(pageWindow.ToneB), toneBDuration);
+
+                        byte[] combinedAudio = new byte[toneA.Length + toneB.Length];
+                        Buffer.BlockCopy(toneA, 0, combinedAudio, 0, toneA.Length);
+                        Buffer.BlockCopy(toneB, 0, combinedAudio, toneA.Length, toneB.Length);
+
+                        int chunkSize = 1600;
+
+                        if (system.IsDvm)
+                            chunkSize = 320;
+
+                        int totalChunks = (combinedAudio.Length + chunkSize - 1) / chunkSize;
+
+                        Task.Run(() =>
+                        {
+                            //_waveProvider.ClearBuffer();
+                            _audioManager.AddTalkgroupStream(cpgChannel.Tgid, combinedAudio);
+                        });
+
+                        await Task.Run(() =>
+                        {
+                            for (int i = 0; i < totalChunks; i++)
+                            {
+                                int offset = i * chunkSize;
+                                int size = Math.Min(chunkSize, combinedAudio.Length - offset);
+
+                                byte[] chunk = new byte[chunkSize];
+                                Buffer.BlockCopy(combinedAudio, offset, chunk, 0, size);
+
+                                if (!system.IsDvm)
+                                {
+                                    IPeer handler = _webSocketManager.GetWebSocketHandler(system.Name);
+
+                                    AudioPacket voicePacket = new AudioPacket
+                                    {
+                                        Data = chunk,
+                                        VoiceChannel = new VoiceChannel
+                                        {
+                                            Frequency = channel.VoiceChannel,
+                                            DstId = cpgChannel.Tgid,
+                                            SrcId = system.Rid,
+                                            Site = system.Site
+                                        },
+                                        Site = system.Site,
+                                        LopServerVocode = true
+                                    };
+
+                                    handler.SendMessage(voicePacket.GetData());
+                                } else
+                                {
+                                    PeerSystem handler = _fneSystemManager.GetFneSystem(system.Name);
+
+                                    if (chunk.Length == 320)
+                                    {
+                                        P25EncodeAudioFrame(chunk, handler, channel, cpgChannel, system);
+                                    }
+                                }
+                            }
+                        });
+
+                        double totalDurationMs = (toneADuration + toneBDuration) * 1000 + 750;
+                        await Task.Delay((int)totalDurationMs);
+
+                        if (!system.IsDvm)
+                        {
+                            IPeer handler = _webSocketManager.GetWebSocketHandler(system.Name);
+
+                            GRP_VCH_RLS release = new GRP_VCH_RLS
+                            {
+                                SrcId = system.Rid,
+                                DstId = cpgChannel.Tgid,
+                                Channel = channel.VoiceChannel,
+                                Site = system.Site
+                            };
+
+                            handler.SendMessage(release.GetData());
+                        } else
+                        {
+                            PeerSystem handler = _fneSystemManager.GetFneSystem(system.Name);
+
+                            await Task.Delay(4000);
+
+                            handler.SendP25TDU(UInt32.Parse(system.Rid), UInt32.Parse(cpgChannel.Tgid), false);
+                        }
+
+                        Dispatcher.Invoke(() =>
+                        {
+                            //channel.PageState = false; // TODO: Investigate
+                            channel.PageSelectButton.Background = channel.grayGradient;
+                        });
+                    }
+                }
+            }
+        }
+
+        private void SendAlertTone(AlertTone e)
+        {
+            Task.Run(() => SendAlertTone(e.AlertFilePath));
+        }
+
+        private void SendAlertTone(string filePath, bool forHold = false)
+        {
+            if (!string.IsNullOrEmpty(filePath) && File.Exists(filePath))
+            {
+                try
+                {
+                    foreach (ChannelBox channel in _selectedChannelsManager.GetSelectedChannels())
+                    {
+                        if (channel.SystemName == PLAYBACKSYS || channel.ChannelName == PLAYBACKCHNAME || channel.DstId == PLAYBACKTG)
+                            continue;
+
+                        Codeplug.System system = Codeplug.GetSystemForChannel(channel.ChannelName);
+                        Codeplug.Channel cpgChannel = Codeplug.GetChannelByName(channel.ChannelName);
+
+                        if (channel.PageState || (forHold && channel.HoldState))
+                        {
+                            byte[] pcmData;
+
+                            Task.Run(async () => {
+                                using (var waveReader = new WaveFileReader(filePath))
+                                {
+                                    if (waveReader.WaveFormat.Encoding != WaveFormatEncoding.Pcm ||
+                                        waveReader.WaveFormat.SampleRate != 8000 ||
+                                        waveReader.WaveFormat.BitsPerSample != 16 ||
+                                        waveReader.WaveFormat.Channels != 1)
+                                    {
+                                        MessageBox.Show("The alert tone must be PCM 16-bit, Mono, 8000Hz format.", "Error", MessageBoxButton.OK, MessageBoxImage.Error);
+                                        return;
+                                    }
+
+                                    using (MemoryStream ms = new MemoryStream())
+                                    {
+                                        waveReader.CopyTo(ms);
+                                        pcmData = ms.ToArray();
+                                    }
+                                }
+
+                                int chunkSize = 1600;
+                                int totalChunks = (pcmData.Length + chunkSize - 1) / chunkSize;
+
+                                if (pcmData.Length % chunkSize != 0)
+                                {
+                                    byte[] paddedData = new byte[totalChunks * chunkSize];
+                                    Buffer.BlockCopy(pcmData, 0, paddedData, 0, pcmData.Length);
+                                    pcmData = paddedData;
+                                }
+
+                                Task.Run(() =>
+                                {
+                                    _audioManager.AddTalkgroupStream(cpgChannel.Tgid, pcmData);
+                                });
+
+                                DateTime startTime = DateTime.UtcNow;
+
+                                for (int i = 0; i < totalChunks; i++)
+                                {
+                                    int offset = i * chunkSize;
+                                    byte[] chunk = new byte[chunkSize];
+                                    Buffer.BlockCopy(pcmData, offset, chunk, 0, chunkSize);
+
+                                    if (!system.IsDvm)
+                                    {
+                                        IPeer handler = _webSocketManager.GetWebSocketHandler(system.Name);
+
+                                        AudioPacket voicePacket = new AudioPacket
+                                        {
+                                            Data = chunk,
+                                            VoiceChannel = new VoiceChannel
+                                            {
+                                                Frequency = channel.VoiceChannel,
+                                                DstId = cpgChannel.Tgid,
+                                                SrcId = system.Rid,
+                                                Site = system.Site
+                                            },
+                                            Site = system.Site,
+                                            LopServerVocode = true
+                                        };
+
+                                        handler.SendMessage(voicePacket.GetData());
+                                    }
+                                    else
+                                    {
+                                        PeerSystem handler = _fneSystemManager.GetFneSystem(system.Name);
+
+                                        channel.chunkedPcm = AudioConverter.SplitToChunks(chunk);
+
+                                        foreach (byte[] smallchunk in channel.chunkedPcm)
+                                        {
+                                            if (smallchunk.Length == 320)
+                                            {
+                                                P25EncodeAudioFrame(smallchunk, handler, channel, cpgChannel, system);
+                                            }
+                                        }
+                                    }
+
+                                    DateTime nextPacketTime = startTime.AddMilliseconds((i + 1) * 100);
+                                    TimeSpan waitTime = nextPacketTime - DateTime.UtcNow;
+
+                                    if (waitTime.TotalMilliseconds > 0)
+                                    {
+                                        await Task.Delay(waitTime);
+                                    }
+                                }
+
+                                double totalDurationMs = ((double)pcmData.Length / 16000) + 250;
+                                await Task.Delay((int)totalDurationMs);
+
+                                if (!system.IsDvm)
+                                {
+                                    IPeer handler = _webSocketManager.GetWebSocketHandler(system.Name);
+
+                                    GRP_VCH_RLS release = new GRP_VCH_RLS
+                                    {
+                                        SrcId = system.Rid,
+                                        DstId = cpgChannel.Tgid,
+                                        Channel = channel.VoiceChannel,
+                                        Site = system.Site
+                                    };
+
+                                    Dispatcher.Invoke(() =>
+                                    {
+                                        handler.SendMessage(release.GetData());
+
+                                        if (forHold)
+                                            channel.PttButton.Background = channel.grayGradient;
+                                        else
+                                            channel.PageState = false;
+                                    });
+                                } else
+                                {
+                                    PeerSystem handler = _fneSystemManager.GetFneSystem(system.Name);
+
+                                    await Task.Delay(3000);
+
+                                    handler.SendP25TDU(UInt32.Parse(system.Rid), UInt32.Parse(cpgChannel.Tgid), false);
+
+                                    Dispatcher.Invoke(() =>
+                                    {
+                                        if (forHold)
+                                            channel.PttButton.Background = channel.grayGradient;
+                                        else
+                                            channel.PageState = false;
+                                    });
+                                }
+                            });
+                        }
+                    }
+                }
+                catch (Exception ex)
+                {
+                    MessageBox.Show($"Failed to process alert tone: {ex.Message}", "Error", MessageBoxButton.OK, MessageBoxImage.Error);
+                }
+            }
+            else
+            {
+                MessageBox.Show("Alert file not set or file not found.", "Alert", MessageBoxButton.OK, MessageBoxImage.Warning);
+            }
+        }
+
+        private void SelectWidgets_Click(object sender, RoutedEventArgs e)
+        {
+            WidgetSelectionWindow widgetSelectionWindow = new WidgetSelectionWindow();
+            widgetSelectionWindow.Owner = this;
+            if (widgetSelectionWindow.ShowDialog() == true)
+            {
+                _settingsManager.ShowSystemStatus = widgetSelectionWindow.ShowSystemStatus;
+                _settingsManager.ShowChannels = widgetSelectionWindow.ShowChannels;
+                _settingsManager.ShowAlertTones = widgetSelectionWindow.ShowAlertTones;
+
+                GenerateChannelWidgets();
+                _settingsManager.SaveSettings();
+            }
+        }
+
+        private void HandleEmergencyAlarmResponse(EMRG_ALRM_RSP response)
+        {
+            bool forUs = false;
+
+            foreach (ChannelBox channel in _selectedChannelsManager.GetSelectedChannels())
+            {
+                Codeplug.System system = Codeplug.GetSystemForChannel(channel.ChannelName);
+                Codeplug.Channel cpgChannel = Codeplug.GetChannelByName(channel.ChannelName);
+
+                if (response.DstId == cpgChannel.Tgid)
+                {
+                    forUs = true;
+                    channel.Emergency = true;
+                    channel.LastSrcId = response.SrcId;
+                }
+            }
+
+            if (forUs)
+            {
+                Dispatcher.Invoke(() =>
+                {
+                    _flashingManager.Start();
+                    _emergencyAlertPlayback.Start();
+                });
+            }
+        }
+
+        private void HandleCallAlert(CALL_ALRT request)
+        {
+            foreach (ChannelBox channel in _selectedChannelsManager.GetSelectedChannels())
+            {
+                Codeplug.System system = Codeplug.GetSystemForChannel(channel.ChannelName);
+                Codeplug.Channel cpgChannel = Codeplug.GetChannelByName(channel.ChannelName);
+
+                if (system.IsDvm)
+                    continue;
+
+                IPeer handler = _webSocketManager.GetWebSocketHandler(system.Name);
+
+                if (request.DstId == system.Rid)
+                {
+
+                    ACK_RSP ack = new ACK_RSP
+                    {
+                        SrcId = request.SrcId,
+                        DstId = request.DstId,
+                        Service = PacketType.CALL_ALRT
+                    };
+
+                    handler.SendMessage(ack.GetData());
+                }
+            }
+        }
+
+        private void HandleReceivedAudio(AudioPacket audioPacket)
+        {
+            bool shouldReceive = false;
+            string talkgroupId = audioPacket.VoiceChannel.DstId;
+
+            foreach (ChannelBox channel in _selectedChannelsManager.GetSelectedChannels())
+            {
+                if (channel.SystemName == PLAYBACKSYS || channel.ChannelName == PLAYBACKCHNAME || channel.DstId == PLAYBACKTG)
+                    continue;
+
+                Codeplug.System system = Codeplug.GetSystemForChannel(channel.ChannelName);
+                Codeplug.Channel cpgChannel = Codeplug.GetChannelByName(channel.ChannelName);
+
+                if (system.IsDvm)
+                    continue;
+
+                if (audioPacket.VoiceChannel.SrcId != system.Rid && audioPacket.VoiceChannel.Frequency == channel.VoiceChannel && audioPacket.VoiceChannel.DstId == cpgChannel.Tgid)
+                    shouldReceive = true;
+            }
+
+            if (shouldReceive)
+                _audioManager.AddTalkgroupStream(talkgroupId, audioPacket.Data);
+        }
+
+        private void HandleAffiliationUpdate(AFF_UPDATE affUpdate)
+        {
+            foreach (ChannelBox channel in _selectedChannelsManager.GetSelectedChannels())
+            {
+                if (channel.SystemName == PLAYBACKSYS || channel.ChannelName == PLAYBACKCHNAME || channel.DstId == PLAYBACKTG)
+                    continue;
+
+                Codeplug.System system = Codeplug.GetSystemForChannel(channel.ChannelName);
+                Codeplug.Channel cpgChannel = Codeplug.GetChannelByName(channel.ChannelName);
+
+                if (system.IsDvm)
+                    continue;
+
+                IPeer handler = _webSocketManager.GetWebSocketHandler(system.Name);
+
+                bool ridExists = affUpdate.Affiliations.Any(aff => aff.SrcId == system.Rid);
+                bool tgidExists = affUpdate.Affiliations.Any(aff => aff.DstId == cpgChannel.Tgid);
+
+                if (ridExists && tgidExists)
+                {
+                    //Console.WriteLine("rid aff'ed");
+                }
+                else
+                {
+                    //Console.WriteLine("rid not aff'ed");
+                    Task.Run(() =>
+                    {
+                        GRP_AFF_REQ affReq = new GRP_AFF_REQ
+                        {
+                            SrcId = system.Rid,
+                            DstId = cpgChannel.Tgid,
+                            Site = system.Site
+                        };
+
+                        handler.SendMessage(affReq.GetData());
+                    });
+                }
+            }
+        }
+
+        private void HandleVoiceRelease(GRP_VCH_RLS response)
+        {
+            foreach (ChannelBox channel in _selectedChannelsManager.GetSelectedChannels())
+            {
+                if (channel.SystemName == PLAYBACKSYS || channel.ChannelName == PLAYBACKCHNAME || channel.DstId == PLAYBACKTG)
+                    continue;
+
+                Codeplug.System system = Codeplug.GetSystemForChannel(channel.ChannelName);
+                Codeplug.Channel cpgChannel = Codeplug.GetChannelByName(channel.ChannelName);
+
+                if (system.IsDvm)
+                    continue;
+
+                IPeer handler = _webSocketManager.GetWebSocketHandler(system.Name);
+
+                if (response.DstId == cpgChannel.Tgid && response.SrcId != system.Rid)
+                {
+                    Dispatcher.Invoke(() =>
+                    {
+                        if (channel.IsSelected)
+                        {
+                            channel.Background = (Brush)new BrushConverter().ConvertFrom("#FF0B004B");
+                            channel.IsReceiving = false;
+                        }
+                        else
+                        {
+                            channel.Background = new SolidColorBrush(Colors.DarkGray);
+                            channel.IsReceiving = false;
+                        }
+                    });
+
+                    channel.VoiceChannel = null;
+                }
+            }
+        }
+
+        private void HandleVoiceResponse(GRP_VCH_RSP response)
+        {
+            foreach (ChannelBox channel in _selectedChannelsManager.GetSelectedChannels())
+            {
+                if (channel.SystemName == PLAYBACKSYS || channel.ChannelName == PLAYBACKCHNAME || channel.DstId == PLAYBACKTG)
+                    continue;
+
+                Codeplug.System system = Codeplug.GetSystemForChannel(channel.ChannelName);
+                Codeplug.Channel cpgChannel = Codeplug.GetChannelByName(channel.ChannelName);
+
+                if (system.IsDvm)
+                    continue;
+
+                IPeer handler = _webSocketManager.GetWebSocketHandler(system.Name);
+
+                if (channel.PttState && response.Status == (int)ResponseType.GRANT && response.Channel != null && response.SrcId == system.Rid && response.DstId == cpgChannel.Tgid)
+                {
+                    channel.VoiceChannel = response.Channel;
+                }
+                else if (response.Status == (int)ResponseType.GRANT && response.SrcId != system.Rid && response.DstId == cpgChannel.Tgid)
+                {
+                    channel.VoiceChannel = response.Channel;
+
+                    string alias = string.Empty;
+
+                    try
+                    {
+                        alias = AliasTools.GetAliasByRid(system.RidAlias, int.Parse(response.SrcId));
+                    }
+                    catch (Exception) { }
+
+                    if (alias.IsNullOrEmpty())
+                        channel.LastSrcId = "Last SRC: " + response.SrcId;
+                    else
+                        channel.LastSrcId = "Last: " + alias;
+
+                    Dispatcher.Invoke(() =>
+                    {
+                        channel.Background = (Brush)new BrushConverter().ConvertFrom("#FF00BC48");
+                        channel.IsReceiving = true;
+                    });
+                }
+                else if ((channel.HoldState || channel.PageState) && response.Status == (int)ResponseType.GRANT && response.Channel != null && response.SrcId == system.Rid && response.DstId == cpgChannel.Tgid)
+                {
+                    channel.VoiceChannel = response.Channel;
+                }
+                else
+                {
+                    //Dispatcher.Invoke(() =>
+                    //{
+                    //    if (channel.IsSelected)
+                    //        channel.Background = new SolidColorBrush(Colors.DodgerBlue);
+                    //    else
+                    //        channel.Background = new SolidColorBrush(Colors.Gray);
+                    //});
+
+                    //channel.VoiceChannel = null;
+                    //_stopSending = true;
+                }
+            }
+        }
+
+        private void ChannelBox_HoldChannelButtonClicked(object sender, ChannelBox e)
+        {
+            if (e.SystemName == PLAYBACKSYS || e.ChannelName == PLAYBACKCHNAME || e.DstId == PLAYBACKTG)
+                return;
+
+            Codeplug.System system = Codeplug.GetSystemForChannel(e.ChannelName);
+            Codeplug.Channel cpgChannel = Codeplug.GetChannelByName(e.ChannelName);
+
+            if (system.IsDvm)
+                return;
+
+            IPeer handler = _webSocketManager.GetWebSocketHandler(system.Name);
+        }
+
+        private void ChannelBox_PageButtonClicked(object sender, ChannelBox e)
+        {
+            if (e.SystemName == PLAYBACKSYS || e.ChannelName == PLAYBACKCHNAME || e.DstId == PLAYBACKTG)
+                return;
+
+            Codeplug.System system = Codeplug.GetSystemForChannel(e.ChannelName);
+            Codeplug.Channel cpgChannel = Codeplug.GetChannelByName(e.ChannelName);
+
+            if (!system.IsDvm)
+            {
+
+                IPeer handler = _webSocketManager.GetWebSocketHandler(system.Name);
+
+                if (e.PageState)
+                {
+                    GRP_VCH_REQ request = new GRP_VCH_REQ
+                    {
+                        SrcId = system.Rid,
+                        DstId = cpgChannel.Tgid,
+                        Site = system.Site
+                    };
+
+                    handler.SendMessage(request.GetData());
+                }
+                else
+                {
+                    GRP_VCH_RLS release = new GRP_VCH_RLS
+                    {
+                        SrcId = system.Rid,
+                        DstId = cpgChannel.Tgid,
+                        Channel = e.VoiceChannel,
+                        Site = system.Site
+                    };
+
+                    handler.SendMessage(release.GetData());
+                    e.VoiceChannel = null;
+                }
+            }
+            else
+            {
+                PeerSystem handler = _fneSystemManager.GetFneSystem(system.Name);
+                if (e.PageState)
+                {
+                    handler.SendP25TDU(UInt32.Parse(system.Rid), UInt32.Parse(cpgChannel.Tgid), true);
+                }
+                else
+                {
+                    handler.SendP25TDU(UInt32.Parse(system.Rid), UInt32.Parse(cpgChannel.Tgid), false);
+                }
+            }
+        }
+
+        private void ChannelBox_PTTButtonClicked(object sender, ChannelBox e)
+        {
+            if (e.SystemName == PLAYBACKSYS || e.ChannelName == PLAYBACKCHNAME || e.DstId == PLAYBACKTG)
+                return;
+
+            Codeplug.System system = Codeplug.GetSystemForChannel(e.ChannelName);
+            Codeplug.Channel cpgChannel = Codeplug.GetChannelByName(e.ChannelName);
+
+            if (!system.IsDvm)
+            {
+                IPeer handler = _webSocketManager.GetWebSocketHandler(system.Name);
+
+                if (!e.IsSelected)
+                    return;
+
+                if (e.PttState)
+                {
+                    GRP_VCH_REQ request = new GRP_VCH_REQ
+                    {
+                        SrcId = system.Rid,
+                        DstId = cpgChannel.Tgid,
+                        Site = system.Site
+                    };
+
+                    handler.SendMessage(request.GetData());
+                }
+                else
+                {
+                    GRP_VCH_RLS release = new GRP_VCH_RLS
+                    {
+                        SrcId = system.Rid,
+                        DstId = cpgChannel.Tgid,
+                        Channel = e.VoiceChannel,
+                        Site = system.Site
+                    };
+
+                    handler.SendMessage(release.GetData());
+                    e.VoiceChannel = null;
+                }
+            } else
+            {
+                PeerSystem handler = _fneSystemManager.GetFneSystem(system.Name);
+
+                if (!e.IsSelected)
+                    return;
+
+                FneUtils.Memset(e.mi, 0x00, P25Defines.P25_MI_LENGTH);
+
+                uint srcId = UInt32.Parse(system.Rid);
+                uint dstId = UInt32.Parse(cpgChannel.Tgid);
+
+                if (e.PttState)
+                {
+                    e.txStreamId = handler.NewStreamId();
+
+                    Console.WriteLine("sending grant demand " + dstId);
+                    handler.SendP25TDU(srcId, dstId, true);
+                }
+                else
+                {
+                    Console.WriteLine("sending terminator " + dstId);
+                    handler.SendP25TDU(srcId, dstId, false);
+                }
+            }
+        }
+
+        private void ChannelBox_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
+        {
+            if (!isEditMode || !(sender is UIElement element)) return;
+
+            _draggedElement = element;
+            _startPoint = e.GetPosition(ChannelsCanvas);
+            _offsetX = _startPoint.X - Canvas.GetLeft(_draggedElement);
+            _offsetY = _startPoint.Y - Canvas.GetTop(_draggedElement);
+            _isDragging = true;
+
+            element.CaptureMouse();
+        }
+
+        private const int GridSize = 5;
+
+        private void ChannelBox_MouseMove(object sender, MouseEventArgs e)
+        {
+            if (!isEditMode || !_isDragging || _draggedElement == null) return;
+
+            Point currentPosition = e.GetPosition(ChannelsCanvas);
+
+            // Calculate the new position with snapping to the grid
+            double newLeft = Math.Round((currentPosition.X - _offsetX) / GridSize) * GridSize;
+            double newTop = Math.Round((currentPosition.Y - _offsetY) / GridSize) * GridSize;
+
+            // Ensure the box stays within canvas bounds
+            newLeft = Math.Max(0, Math.Min(newLeft, ChannelsCanvas.ActualWidth - _draggedElement.RenderSize.Width));
+            newTop = Math.Max(0, Math.Min(newTop, ChannelsCanvas.ActualHeight - _draggedElement.RenderSize.Height));
+
+            // Apply snapped position
+            Canvas.SetLeft(_draggedElement, newLeft);
+            Canvas.SetTop(_draggedElement, newTop);
+
+            // Save the new position if it's a ChannelBox
+            if (_draggedElement is ChannelBox channelBox)
+            {
+                _settingsManager.UpdateChannelPosition(channelBox.ChannelName, newLeft, newTop);
+            }
+
+            AdjustCanvasHeight();
+        }
+
+        private void ChannelBox_MouseRightButtonDown(object sender, MouseButtonEventArgs e)
+        {
+            if (!isEditMode || !_isDragging || _draggedElement == null) return;
+
+            _isDragging = false;
+            _draggedElement.ReleaseMouseCapture();
+            _draggedElement = null;
+        }
+
+        private void SystemStatusBox_MouseLeftButtonDown(object sender, MouseButtonEventArgs e) => ChannelBox_MouseLeftButtonDown(sender, e);
+        private void SystemStatusBox_MouseMove(object sender, MouseEventArgs e) => ChannelBox_MouseMove(sender, e);
+
+        private void SystemStatusBox_MouseRightButtonDown(object sender, MouseButtonEventArgs e)
+        {
+            if (!isEditMode) return;
+
+            if (sender is SystemStatusBox systemStatusBox)
+            {
+                double x = Canvas.GetLeft(systemStatusBox);
+                double y = Canvas.GetTop(systemStatusBox);
+                _settingsManager.SystemStatusPositions[systemStatusBox.SystemName] = new ChannelPosition { X = x, Y = y };
+
+                ChannelBox_MouseRightButtonDown(sender, e);
+
+                AdjustCanvasHeight();
+            }
+        }
+
+        private void ToggleEditMode_Click(object sender, RoutedEventArgs e)
+        {
+            isEditMode = !isEditMode;
+            var menuItem = (MenuItem)sender;
+            menuItem.Header = isEditMode ? "Disable Edit Mode" : "Enable Edit Mode";
+            UpdateEditModeForWidgets();
+        }
+
+        private void UpdateEditModeForWidgets()
+        {
+            foreach (var child in ChannelsCanvas.Children)
+            {
+                if (child is AlertTone alertTone)
+                {
+                    alertTone.IsEditMode = isEditMode;
+                }
+
+                if (child is ChannelBox channelBox)
+                {
+                    channelBox.IsEditMode = isEditMode;
+                }
+            }
+        }
+
+        private void AddAlertTone_Click(object sender, RoutedEventArgs e)
+        {
+            OpenFileDialog openFileDialog = new OpenFileDialog
+            {
+                Filter = "WAV Files (*.wav)|*.wav|All Files (*.*)|*.*",
+                Title = "Select Alert Tone"
+            };
+
+            if (openFileDialog.ShowDialog() == true)
+            {
+                string alertFilePath = openFileDialog.FileName;
+                var alertTone = new AlertTone(alertFilePath)
+                {
+                    IsEditMode = isEditMode
+                };
+
+                alertTone.OnAlertTone += SendAlertTone;
+
+                if (_settingsManager.AlertTonePositions.TryGetValue(alertFilePath, out var position))
+                {
+                    Canvas.SetLeft(alertTone, position.X);
+                    Canvas.SetTop(alertTone, position.Y);
+                }
+                else
+                {
+                    Canvas.SetLeft(alertTone, 20);
+                    Canvas.SetTop(alertTone, 20);
+                }
+
+                alertTone.MouseRightButtonUp += AlertTone_MouseRightButtonUp;
+
+                ChannelsCanvas.Children.Add(alertTone);
+                _settingsManager.UpdateAlertTonePaths(alertFilePath);
+
+                AdjustCanvasHeight();
+            }
+        }
+
+        private void AlertTone_MouseRightButtonUp(object sender, MouseButtonEventArgs e)
+        {
+            if (!isEditMode) return;
+
+            if (sender is AlertTone alertTone)
+            {
+                double x = Canvas.GetLeft(alertTone);
+                double y = Canvas.GetTop(alertTone);
+                _settingsManager.UpdateAlertTonePosition(alertTone.AlertFilePath, x, y);
+
+                AdjustCanvasHeight();
+            }
+        }
+
+        private void AdjustCanvasHeight()
+        {
+            double maxBottom = 0;
+
+            foreach (UIElement child in ChannelsCanvas.Children)
+            {
+                double childBottom = Canvas.GetTop(child) + child.RenderSize.Height;
+                if (childBottom > maxBottom)
+                {
+                    maxBottom = childBottom;
+                }
+            }
+
+            ChannelsCanvas.Height = maxBottom + 150;
+        }
+
+        private void MainWindow_Loaded(object sender, RoutedEventArgs e)
+        {
+            if (!string.IsNullOrEmpty(_settingsManager.LastCodeplugPath) && File.Exists(_settingsManager.LastCodeplugPath))
+            {
+                LoadCodeplug(_settingsManager.LastCodeplugPath);
+            }
+            else
+            {
+                GenerateChannelWidgets();
+            }
+        }
+
+        private async void OnHoldTimerElapsed(object sender, ElapsedEventArgs e)
+        {
+            foreach (ChannelBox channel in _selectedChannelsManager.GetSelectedChannels())
+            {
+                if (channel.SystemName == PLAYBACKSYS || channel.ChannelName == PLAYBACKCHNAME || channel.DstId == PLAYBACKTG)
+                    continue;
+
+                Codeplug.System system = Codeplug.GetSystemForChannel(channel.ChannelName);
+                Codeplug.Channel cpgChannel = Codeplug.GetChannelByName(channel.ChannelName);
+
+                if (!system.IsDvm)
+                {
+
+                    IPeer handler = _webSocketManager.GetWebSocketHandler(system.Name);
+
+                    if (channel.HoldState && !channel.IsReceiving && !channel.PttState && !channel.PageState)
+                    {
+                        //Task.Factory.StartNew(async () =>
+                        //{
+                        Console.WriteLine("Sending channel hold beep");
+
+                        Dispatcher.Invoke(() => { channel.PttButton.Background = channel.redGradient; });
+
+                        GRP_VCH_REQ req = new GRP_VCH_REQ
+                        {
+                            SrcId = system.Rid,
+                            DstId = cpgChannel.Tgid,
+                            Site = system.Site
+                        };
+
+                        handler.SendMessage(req.GetData());
+
+                        await Task.Delay(1000);
+
+                        SendAlertTone("hold.wav", true);
+                        // });
+                    }
+                } else
+                {
+                    PeerSystem handler = _fneSystemManager.GetFneSystem(system.Name);
+
+                    if (channel.HoldState && !channel.IsReceiving && !channel.PttState && !channel.PageState)
+                    {
+                        handler.SendP25TDU(UInt32.Parse(system.Rid), UInt32.Parse(cpgChannel.Tgid), true);
+                        await Task.Delay(1000);
+
+                        SendAlertTone("hold.wav", true);
+                    }
+                }
+            }
+        }
+
+        protected override void OnClosing(System.ComponentModel.CancelEventArgs e)
+        {
+            _settingsManager.SaveSettings();
+            base.OnClosing(e);
+            Application.Current.Shutdown();
+        }
+
+        private void ClearEmergency_Click(object sender, RoutedEventArgs e)
+        {
+            _emergencyAlertPlayback.Stop();
+            _flashingManager.Stop();
+
+            foreach (ChannelBox channel in _selectedChannelsManager.GetSelectedChannels())
+            {
+                channel.Emergency = false;
+            }
+        }
+
+        private void btnAlert1_Click(object sender, RoutedEventArgs e)
+        {
+            Dispatcher.Invoke(() => {
+                SendAlertTone("alert1.wav");
+            });
+        }
+
+        private void btnAlert2_Click(object sender, RoutedEventArgs e)
+        {
+            Dispatcher.Invoke(() =>
+            {
+                SendAlertTone("alert2.wav");
+            });
+        }
+
+        private void btnAlert3_Click(object sender, RoutedEventArgs e)
+        {
+            Dispatcher.Invoke(() =>
+            {
+                SendAlertTone("alert3.wav");
+            });
+        }
+
+        private async void btnGlobalPtt_Click(object sender, RoutedEventArgs e)
+        {
+            if (globalPttState)
+                await Task.Delay(500);
+
+            globalPttState = !globalPttState;
+
+            foreach (ChannelBox channel in _selectedChannelsManager.GetSelectedChannels())
+            {
+                if (channel.SystemName == PLAYBACKSYS || channel.ChannelName == PLAYBACKCHNAME || channel.DstId == PLAYBACKTG)
+                    continue;
+
+                Codeplug.System system = Codeplug.GetSystemForChannel(channel.ChannelName);
+                Codeplug.Channel cpgChannel = Codeplug.GetChannelByName(channel.ChannelName);
+
+                if (!system.IsDvm)
+                {
+                    IPeer handler = _webSocketManager.GetWebSocketHandler(system.Name);
+
+                    if (!channel.IsSelected)
+                        continue;
+
+                    if (globalPttState)
+                    {
+                        Dispatcher.Invoke(() =>
+                        {
+                            btnGlobalPtt.Background = channel.redGradient;
+                        });
+
+
+                        GRP_VCH_REQ request = new GRP_VCH_REQ
+                        {
+                            SrcId = system.Rid,
+                            DstId = cpgChannel.Tgid,
+                            Site = system.Site
+                        };
+
+                        channel.PttState = true;
+
+                        handler.SendMessage(request.GetData());
+                    }
+                    else
+                    {
+                        Dispatcher.Invoke(() =>
+                        {
+                            btnGlobalPtt.Background = channel.grayGradient;
+                        });
+
+                        GRP_VCH_RLS release = new GRP_VCH_RLS
+                        {
+                            SrcId = system.Rid,
+                            DstId = cpgChannel.Tgid,
+                            Site = system.Site
+                        };
+
+                        channel.PttState = false;
+
+                        handler.SendMessage(release.GetData());
+                    }
+                } else
+                {
+                    PeerSystem handler = _fneSystemManager.GetFneSystem(system.Name);
+
+                    channel.txStreamId = handler.NewStreamId();
+
+                    if (globalPttState)
+                    {
+                        Dispatcher.Invoke(() =>
+                        {
+                            btnGlobalPtt.Background = channel.redGradient;
+                            channel.PttState = true;
+                        });
+
+                        handler.SendP25TDU(UInt32.Parse(system.Rid), UInt32.Parse(cpgChannel.Tgid), true);
+                    }
+                    else
+                    {
+                        Dispatcher.Invoke(() =>
+                        {
+                            btnGlobalPtt.Background = channel.grayGradient;
+                            channel.PttState = false;
+                        });
+
+                        handler.SendP25TDU(UInt32.Parse(system.Rid), UInt32.Parse(cpgChannel.Tgid), false);
+                    }
+                }
+            }
+        }
+
+        private void Button_Click(object sender, RoutedEventArgs e) { /* sub */ }
+
+        private void SelectAll_Click(object sender, RoutedEventArgs e)
+        {
+            foreach (ChannelBox channel in ChannelsCanvas.Children.OfType<ChannelBox>())
+            {
+                if (channel.SystemName == PLAYBACKSYS || channel.ChannelName == PLAYBACKCHNAME || channel.DstId == PLAYBACKTG)
+                    continue;
+
+                Codeplug.System system = Codeplug.GetSystemForChannel(channel.ChannelName);
+                Codeplug.Channel cpgChannel = Codeplug.GetChannelByName(channel.ChannelName);
+
+                if (!channel.IsSelected)
+                {
+                    channel.IsSelected = true;
+
+                    channel.Background = channel.IsSelected ? (Brush)new BrushConverter().ConvertFrom("#FF0B004B") : Brushes.Gray;
+
+                    if (channel.IsSelected)
+                    {
+                        _selectedChannelsManager.AddSelectedChannel(channel);
+                    }
+                    else
+                    {
+                        _selectedChannelsManager.RemoveSelectedChannel(channel);
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Helper to encode and transmit PCM audio as P25 IMBE frames.
+        /// </summary>
+        private void P25EncodeAudioFrame(byte[] pcm, PeerSystem handler, ChannelBox channel, Codeplug.Channel cpgChannel, Codeplug.System system)
+        {
+            bool encryptCall = true; // TODO: make this dynamic somewhere?
+
+            if (channel.p25N > 17)
+                channel.p25N = 0;
+            if (channel.p25N == 0)
+                FneUtils.Memset(channel.netLDU1, 0, 9 * 25);
+            if (channel.p25N == 9)
+                FneUtils.Memset(channel.netLDU2, 0, 9 * 25);
+
+            // Log.Logger.Debug($"BYTE BUFFER {FneUtils.HexDump(pcm)}");
+
+            //// pre-process: apply gain to PCM audio frames
+            //if (Program.Configuration.TxAudioGain != 1.0f)
+            //{
+            //    BufferedWaveProvider buffer = new BufferedWaveProvider(waveFormat);
+            //    buffer.AddSamples(pcm, 0, pcm.Length);
+
+            //    VolumeWaveProvider16 gainControl = new VolumeWaveProvider16(buffer);
+            //    gainControl.Volume = Program.Configuration.TxAudioGain;
+            //    gainControl.Read(pcm, 0, pcm.Length);
+            //}
+
+            int smpIdx = 0;
+            short[] samples = new short[FneSystemBase.MBE_SAMPLES_LENGTH];
+            for (int pcmIdx = 0; pcmIdx < pcm.Length; pcmIdx += 2)
+            {
+                samples[smpIdx] = (short)((pcm[pcmIdx + 1] << 8) + pcm[pcmIdx + 0]);
+                smpIdx++;
+            }
+
+            // Convert to floats
+            float[] fSamples = AudioConverter.PcmToFloat(samples);
+
+            // Convert to signal
+            DiscreteSignal signal = new DiscreteSignal(8000, fSamples, true);
+
+            // Log.Logger.Debug($"SAMPLE BUFFER {FneUtils.HexDump(samples)}");
+
+            // encode PCM samples into IMBE codewords
+            byte[] imbe = new byte[FneSystemBase.IMBE_BUF_LEN];
+
+
+            int tone = 0;
+
+            if (true) // TODO: Disable/enable detection
+            {
+                tone = channel.toneDetector.Detect(signal);
+            }
+            if (tone > 0)
+            {
+                MBEToneGenerator.IMBEEncodeSingleTone((ushort)tone, imbe);
+                Console.WriteLine($"({system.Name}) P25D: {tone} HZ TONE DETECT");
+            }
+            else
+            {
+#if WIN32
+                if (channel.extFullRateVocoder == null)
+                    channel.extFullRateVocoder = new AmbeVocoder(true);
+
+                channel.extFullRateVocoder.encode(samples, out imbe);
+#else
+                if (channel.encoder == null)
+                    channel.encoder = new MBEEncoder(MBE_MODE.IMBE_88BIT);
+
+                channel.encoder.encode(samples, imbe);
+#endif
+            }
+            // Log.Logger.Debug($"IMBE {FneUtils.HexDump(imbe)}");
+
+            if (encryptCall && cpgChannel.GetAlgoId() != 0 && cpgChannel.GetKeyId() != 0)
+            {
+                // initial HDU MI
+                if (channel.p25N == 0)
+                {
+                    if (channel.mi.All(b => b == 0))
+                    {
+                        Random random = new Random();
+
+                        for (int i = 0; i < P25Defines.P25_MI_LENGTH; i++)
+                        {
+                            channel.mi[i] = (byte)random.Next(0x00, 0x100);
+                        }
+                    }
+
+                    channel.crypter.Prepare(cpgChannel.GetAlgoId(), cpgChannel.GetKeyId(), ProtocolType.P25Phase1, channel.mi);
+                }
+
+                // crypto time
+                channel.crypter.Process(imbe, channel.p25N < 9U ? P25Crypto.FrameType.LDU1 : P25Crypto.FrameType.LDU2, 0);
+
+                // last block of LDU2, prepare a new MI
+                if (channel.p25N == 17U)
+                {
+                    P25Crypto.CycleP25Lfsr(channel.mi);
+                    channel.crypter.Prepare(cpgChannel.GetAlgoId(), cpgChannel.GetKeyId(), ProtocolType.P25Phase1, channel.mi);
+                }
+            }
+
+            // fill the LDU buffers appropriately
+            switch (channel.p25N)
+            {
+                // LDU1
+                case 0:
+                    Buffer.BlockCopy(imbe, 0, channel.netLDU1, 10, FneSystemBase.IMBE_BUF_LEN);
+                    break;
+                case 1:
+                    Buffer.BlockCopy(imbe, 0, channel.netLDU1, 26, FneSystemBase.IMBE_BUF_LEN);
+                    break;
+                case 2:
+                    Buffer.BlockCopy(imbe, 0, channel.netLDU1, 55, FneSystemBase.IMBE_BUF_LEN);
+                    break;
+                case 3:
+                    Buffer.BlockCopy(imbe, 0, channel.netLDU1, 80, FneSystemBase.IMBE_BUF_LEN);
+                    break;
+                case 4:
+                    Buffer.BlockCopy(imbe, 0, channel.netLDU1, 105, FneSystemBase.IMBE_BUF_LEN);
+                    break;
+                case 5:
+                    Buffer.BlockCopy(imbe, 0, channel.netLDU1, 130, FneSystemBase.IMBE_BUF_LEN);
+                    break;
+                case 6:
+                    Buffer.BlockCopy(imbe, 0, channel.netLDU1, 155, FneSystemBase.IMBE_BUF_LEN);
+                    break;
+                case 7:
+                    Buffer.BlockCopy(imbe, 0, channel.netLDU1, 180, FneSystemBase.IMBE_BUF_LEN);
+                    break;
+                case 8:
+                    Buffer.BlockCopy(imbe, 0, channel.netLDU1, 204, FneSystemBase.IMBE_BUF_LEN);
+                    break;
+
+                // LDU2
+                case 9:
+                    Buffer.BlockCopy(imbe, 0, channel.netLDU2, 10, FneSystemBase.IMBE_BUF_LEN);
+                    break;
+                case 10:
+                    Buffer.BlockCopy(imbe, 0, channel.netLDU2, 26, FneSystemBase.IMBE_BUF_LEN);
+                    break;
+                case 11:
+                    Buffer.BlockCopy(imbe, 0, channel.netLDU2, 55, FneSystemBase.IMBE_BUF_LEN);
+                    break;
+                case 12:
+                    Buffer.BlockCopy(imbe, 0, channel.netLDU2, 80, FneSystemBase.IMBE_BUF_LEN);
+                    break;
+                case 13:
+                    Buffer.BlockCopy(imbe, 0, channel.netLDU2, 105, FneSystemBase.IMBE_BUF_LEN);
+                    break;
+                case 14:
+                    Buffer.BlockCopy(imbe, 0, channel.netLDU2, 130, FneSystemBase.IMBE_BUF_LEN);
+                    break;
+                case 15:
+                    Buffer.BlockCopy(imbe, 0, channel.netLDU2, 155, FneSystemBase.IMBE_BUF_LEN);
+                    break;
+                case 16:
+                    Buffer.BlockCopy(imbe, 0, channel.netLDU2, 180, FneSystemBase.IMBE_BUF_LEN);
+                    break;
+                case 17:
+                    Buffer.BlockCopy(imbe, 0, channel.netLDU2, 204, FneSystemBase.IMBE_BUF_LEN);
+                    break;
+            }
+
+            uint srcId = UInt32.Parse(system.Rid);
+            uint dstId = UInt32.Parse(cpgChannel.Tgid);
+
+            FnePeer peer = handler.peer;
+            RemoteCallData callData = new RemoteCallData()
+            {
+                SrcId = srcId,
+                DstId = dstId,
+                LCO = P25Defines.LC_GROUP
+            };
+
+            // send P25 LDU1
+            if (channel.p25N == 8U)
+            {
+                ushort pktSeq = 0;
+                if (channel.p25SeqNo == 0U)
+                    pktSeq = peer.pktSeq(true);
+                else
+                    pktSeq = peer.pktSeq();
+
+                //Console.WriteLine($"({channel.SystemName}) P25D: Traffic *VOICE FRAME    * PEER {handler.PeerId} SRC_ID {srcId} TGID {dstId} [STREAM ID {channel.txStreamId}]");
+
+                byte[] payload = new byte[200];
+                handler.CreateNewP25MessageHdr((byte)P25DUID.LDU1, callData, ref payload, cpgChannel.GetAlgoId(), cpgChannel.GetKeyId(), channel.mi);
+                handler.CreateP25LDU1Message(channel.netLDU1, ref payload, srcId, dstId);
+
+                peer.SendMaster(new Tuple<byte, byte>(Constants.NET_FUNC_PROTOCOL, Constants.NET_PROTOCOL_SUBFUNC_P25), payload, pktSeq, channel.txStreamId);
+            }
+
+            // send P25 LDU2
+            if (channel.p25N == 17U)
+            {
+                ushort pktSeq = 0;
+                if (channel.p25SeqNo == 0U)
+                    pktSeq = peer.pktSeq(true);
+                else
+                    pktSeq = peer.pktSeq();
+
+                //Console.WriteLine($"({channel.SystemName}) P25D: Traffic *VOICE FRAME    * PEER {handler.PeerId} SRC_ID {srcId} TGID {dstId} [STREAM ID {channel.txStreamId}]");
+
+                byte[] payload = new byte[200];
+                handler.CreateNewP25MessageHdr((byte)P25DUID.LDU2, callData, ref payload, cpgChannel.GetAlgoId(), cpgChannel.GetKeyId(), channel.mi);
+                handler.CreateP25LDU2Message(channel.netLDU2, ref payload, new CryptoParams { AlgId = cpgChannel.GetAlgoId(), KeyId = cpgChannel.GetKeyId(), Mi = channel.mi });
+
+                peer.SendMaster(new Tuple<byte, byte>(Constants.NET_FUNC_PROTOCOL, Constants.NET_PROTOCOL_SUBFUNC_P25), payload, pktSeq, channel.txStreamId);
+            }
+
+            channel.p25SeqNo++;
+            channel.p25N++;
+        }
+
+        /// <summary>
+        /// Helper to decode and playback P25 IMBE frames as PCM audio.
+        /// </summary>
+        /// <param name="ldu"></param>
+        /// <param name="e"></param>
+        private void P25DecodeAudioFrame(byte[] ldu, P25DataReceivedEvent e, PeerSystem system, ChannelBox channel, bool emergency = false, P25Crypto.FrameType frameType = P25Crypto.FrameType.LDU1)
+        {
+            try
+            {
+                // decode 9 IMBE codewords into PCM samples
+                for (int n = 0; n < 9; n++)
+                {
+                    byte[] imbe = new byte[FneSystemBase.IMBE_BUF_LEN];
+                    switch (n)
+                    {
+                        case 0:
+                            Buffer.BlockCopy(ldu, 10, imbe, 0, FneSystemBase.IMBE_BUF_LEN);
+                            break;
+                        case 1:
+                            Buffer.BlockCopy(ldu, 26, imbe, 0, FneSystemBase.IMBE_BUF_LEN);
+                            break;
+                        case 2:
+                            Buffer.BlockCopy(ldu, 55, imbe, 0, FneSystemBase.IMBE_BUF_LEN);
+                            break;
+                        case 3:
+                            Buffer.BlockCopy(ldu, 80, imbe, 0, FneSystemBase.IMBE_BUF_LEN);
+                            break;
+                        case 4:
+                            Buffer.BlockCopy(ldu, 105, imbe, 0, FneSystemBase.IMBE_BUF_LEN);
+                            break;
+                        case 5:
+                            Buffer.BlockCopy(ldu, 130, imbe, 0, FneSystemBase.IMBE_BUF_LEN);
+                            break;
+                        case 6:
+                            Buffer.BlockCopy(ldu, 155, imbe, 0, FneSystemBase.IMBE_BUF_LEN);
+                            break;
+                        case 7:
+                            Buffer.BlockCopy(ldu, 180, imbe, 0, FneSystemBase.IMBE_BUF_LEN);
+                            break;
+                        case 8:
+                            Buffer.BlockCopy(ldu, 204, imbe, 0, FneSystemBase.IMBE_BUF_LEN);
+                            break;
+                    }
+
+                    //Log.Logger.Debug($"Decoding IMBE buffer: {FneUtils.HexDump(imbe)}");
+
+                    short[] samples = new short[FneSystemBase.MBE_SAMPLES_LENGTH];
+
+                    channel.crypter.Process(imbe, frameType, n);
+
+#if WIN32
+                    if (channel.extFullRateVocoder == null)
+                        channel.extFullRateVocoder = new AmbeVocoder(true);
+
+                    channel.p25Errs = channel.extFullRateVocoder.decode(imbe, out samples);
+#else
+
+                    channel.p25Errs = channel.decoder.decode(imbe, samples);
+#endif
+
+                    if (emergency)
+                    {
+                        if (!channel.Emergency)
+                        {
+                            Task.Run(() =>
+                            {
+                                HandleEmergencyAlarmResponse(new EMRG_ALRM_RSP
+                                {
+                                    SrcId = e.SrcId.ToString(),
+                                    DstId = e.DstId.ToString()
+                                });
+                            });
+                        }
+                    }
+
+                    if (samples != null)
+                    {
+                        //Log.Logger.Debug($"({Config.Name}) P25D: Traffic *VOICE FRAME    * PEER {e.PeerId} SRC_ID {e.SrcId} TGID {e.DstId} VC{n} ERRS {errs} [STREAM ID {e.StreamId}]");
+                        //Log.Logger.Debug($"IMBE {FneUtils.HexDump(imbe)}");
+                        //Console.WriteLine($"SAMPLE BUFFER {FneUtils.HexDump(samples)}");
+
+                        int pcmIdx = 0;
+                        byte[] pcmData = new byte[samples.Length * 2];
+                        for (int i = 0; i < samples.Length; i++)
+                        {
+                            pcmData[pcmIdx] = (byte)(samples[i] & 0xFF);
+                            pcmData[pcmIdx + 1] = (byte)((samples[i] >> 8) & 0xFF);
+                            pcmIdx += 2;
+                        }
+
+                        _audioManager.AddTalkgroupStream(e.DstId.ToString(), pcmData);
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"Audio Decode Exception: {ex.Message}");
+            }
+        }
+
+        private uint GetUniqueRid(string ridString)
+        {
+            uint rid;
+
+            // Try to parse the RID, default to 1000 if parsing fails
+            if (!UInt32.TryParse(ridString, out rid))
+            {
+                rid = 1000;
+            }
+
+            // Ensure uniqueness by incrementing if needed
+            while (usedRids.Contains(rid))
+            {
+                rid++;
+            }
+
+            // Store the new unique RID
+            usedRids.Add(rid);
+
+            return rid;
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="e"></param>
+        public void KeyResponseReceived(KeyResponseEvent e)
+        {
+            //Console.WriteLine($"Message ID: {e.KmmKey.MessageId}");
+            //Console.WriteLine($"Decrypt Info Format: {e.KmmKey.DecryptInfoFmt}");
+            //Console.WriteLine($"Algorithm ID: {e.KmmKey.AlgId}");
+            //Console.WriteLine($"Key ID: {e.KmmKey.KeyId}");
+            //Console.WriteLine($"Keyset ID: {e.KmmKey.KeysetItem.KeysetId}");
+            //Console.WriteLine($"Keyset Alg ID: {e.KmmKey.KeysetItem.AlgId}");
+            //Console.WriteLine($"Keyset Key Length: {e.KmmKey.KeysetItem.KeyLength}");
+            //Console.WriteLine($"Number of Keys: {e.KmmKey.KeysetItem.Keys.Count}");
+
+            foreach (var key in e.KmmKey.KeysetItem.Keys)
+            {
+                //Console.WriteLine($"  Key Format: {key.KeyFormat}");
+                //Console.WriteLine($"  SLN: {key.Sln}");
+                //Console.WriteLine($"  Key ID: {key.KeyId}");
+                //Console.WriteLine($"  Key Data: {BitConverter.ToString(key.GetKey())}");
+
+                Dispatcher.Invoke(() =>
+                {
+                    foreach (ChannelBox channel in _selectedChannelsManager.GetSelectedChannels())
+                    {
+                        Codeplug.System system = Codeplug.GetSystemForChannel(channel.ChannelName);
+                        Codeplug.Channel cpgChannel = Codeplug.GetChannelByName(channel.ChannelName);
+
+                        if (!system.IsDvm)
+                            continue;
+
+                        PeerSystem handler = _fneSystemManager.GetFneSystem(system.Name);
+
+                        if (cpgChannel.GetKeyId() != 0 && cpgChannel.GetAlgoId() != 0)
+                            channel.crypter.AddKey(key.KeyId, e.KmmKey.KeysetItem.AlgId, key.GetKey());
+                    }
+                });
+            }
+        }
+
+        private void KeyStatus_Click(object sender, RoutedEventArgs e)
+        {
+            KeyStatusWindow keyStatus = new KeyStatusWindow(Codeplug, this);
+            keyStatus.Show();
+        }
+
+        /// <summary>
+        /// Event handler used to process incoming P25 data.
+        /// </summary>
+        /// <param name="sender"></param>
+        /// <param name="e"></param>
+        public void P25DataReceived(P25DataReceivedEvent e, DateTime pktTime)
+        {
+            uint sysId = (uint)((e.Data[11U] << 8) | (e.Data[12U] << 0));
+            uint netId = FneUtils.Bytes3ToUInt32(e.Data, 16);
+            byte control = e.Data[14U];
+
+            byte len = e.Data[23];
+            byte[] data = new byte[len];
+            for (int i = 24; i < len; i++)
+                data[i - 24] = e.Data[i];
+
+            Dispatcher.Invoke(() =>
+            {
+                foreach (ChannelBox channel in _selectedChannelsManager.GetSelectedChannels())
+                {
+                    Codeplug.System system = Codeplug.GetSystemForChannel(channel.ChannelName);
+                    Codeplug.Channel cpgChannel = Codeplug.GetChannelByName(channel.ChannelName);
+
+                    bool isEmergency = false;
+                    bool encrypted = false;
+
+                    if (!system.IsDvm)
+                        continue;
+
+                    PeerSystem handler = _fneSystemManager.GetFneSystem(system.Name);
+
+                    if (!channel.IsEnabled)
+                        continue;
+
+                    if (cpgChannel.Tgid != e.DstId.ToString())
+                        continue;
+
+                    if (!systemStatuses.ContainsKey(cpgChannel.Name))
+                    {
+                        systemStatuses[cpgChannel.Name] = new SlotStatus();
+                    }
+
+                    if (channel.decoder == null)
+                    {
+                        channel.decoder = new MBEDecoder(MBE_MODE.IMBE_88BIT);
+                    }
+
+                    SlotStatus slot = systemStatuses[cpgChannel.Name];
+
+                    // if this is an LDU1 see if this is the first LDU with HDU encryption data
+                    if (e.DUID == P25DUID.LDU1)
+                    {
+                        byte frameType = e.Data[180];
+
+                        // get the initial MI and other enc info (bug found by the screeeeeeeeech on initial tx...)
+                        if (frameType == P25Defines.P25_FT_HDU_VALID)
+                        {
+                            channel.algId = e.Data[181];
+                            channel.kId = (ushort)((e.Data[182] << 8) | e.Data[183]);
+                            Array.Copy(e.Data, 184, channel.mi, 0, P25Defines.P25_MI_LENGTH);
+
+                            channel.crypter.Prepare(channel.algId, channel.kId, P25Crypto.ProtocolType.P25Phase1, channel.mi);
+
+                            encrypted = true;
+                        }
+                    }
+
+                    // is this a new call stream?
+                    if (e.StreamId != slot.RxStreamId && ((e.DUID != P25DUID.TDU) && (e.DUID != P25DUID.TDULC)))
+                    {
+                        channel.IsReceiving = true;
+                        slot.RxStart = pktTime;
+                        Console.WriteLine($"({system.Name}) P25D: Traffic *CALL START     * PEER {e.PeerId} SRC_ID {e.SrcId} TGID {e.DstId} [STREAM ID {e.StreamId}]");
+
+                        FneUtils.Memset(channel.mi, 0x00, P25Defines.P25_MI_LENGTH);
+
+                        callHistoryWindow.AddCall(cpgChannel.Name, (int)e.SrcId, (int)e.DstId);
+                        callHistoryWindow.ChannelKeyed(cpgChannel.Name, (int)e.SrcId, encrypted);
+
+                        string alias = string.Empty;
+
+                        try
+                        {
+                            alias = AliasTools.GetAliasByRid(system.RidAlias, (int)e.SrcId);
+                        }
+                        catch (Exception) { }
+
+                        if (alias.IsNullOrEmpty())
+                            channel.LastSrcId = "Last SRC: " + e.SrcId;
+                        else
+                            channel.LastSrcId = "Last: " + alias;
+
+                        if (channel.algId != P25Defines.P25_ALGO_UNENCRYPT)
+                            channel.Background = (Brush)new BrushConverter().ConvertFrom("#ffdeaf0a");
+                        else
+                            channel.Background = (Brush)new BrushConverter().ConvertFrom("#FF00BC48");
+                    }
+
+                    // Is the call over?
+                    if (((e.DUID == P25DUID.TDU) || (e.DUID == P25DUID.TDULC)) && (slot.RxType != fnecore.FrameType.TERMINATOR))
+                    {
+                        channel.IsReceiving = false;
+                        TimeSpan callDuration = pktTime - slot.RxStart;
+                        Console.WriteLine($"({system.Name}) P25D: Traffic *CALL END       * PEER {e.PeerId} SRC_ID {e.SrcId} TGID {e.DstId} DUR {callDuration} [STREAM ID {e.StreamId}]");
+                        channel.Background = (Brush)new BrushConverter().ConvertFrom("#FF0B004B");
+                        callHistoryWindow.ChannelUnkeyed(cpgChannel.Name, (int)e.SrcId);
+                        return;
+                    }
+
+                    if ((channel.algId != cpgChannel.GetAlgoId() || channel.kId != cpgChannel.GetKeyId()) && channel.algId != P25Defines.P25_ALGO_UNENCRYPT)
+                        continue;
+
+                    byte[] newMI = new byte[P25Defines.P25_MI_LENGTH];
+
+                    int count = 0;
+
+                    switch (e.DUID)
+                    {
+                        case P25DUID.LDU1:
+                            {
+                                // The '62', '63', '64', '65', '66', '67', '68', '69', '6A' records are LDU1
+                                if ((data[0U] == 0x62U) && (data[22U] == 0x63U) &&
+                                    (data[36U] == 0x64U) && (data[53U] == 0x65U) &&
+                                    (data[70U] == 0x66U) && (data[87U] == 0x67U) &&
+                                    (data[104U] == 0x68U) && (data[121U] == 0x69U) &&
+                                    (data[138U] == 0x6AU))
+                                {
+                                    // The '62' record - IMBE Voice 1
+                                    Buffer.BlockCopy(data, count, channel.netLDU1, 0, 22);
+                                    count += 22;
+
+                                    // The '63' record - IMBE Voice 2
+                                    Buffer.BlockCopy(data, count, channel.netLDU1, 25, 14);
+                                    count += 14;
+
+                                    // The '64' record - IMBE Voice 3 + Link Control
+                                    Buffer.BlockCopy(data, count, channel.netLDU1, 50, 17);
+                                    byte serviceOptions = data[count + 3];
+                                    isEmergency = (serviceOptions & 0x80) == 0x80;
+                                    count += 17;
+
+                                    // The '65' record - IMBE Voice 4 + Link Control
+                                    Buffer.BlockCopy(data, count, channel.netLDU1, 75, 17);
+                                    count += 17;
+
+                                    // The '66' record - IMBE Voice 5 + Link Control
+                                    Buffer.BlockCopy(data, count, channel.netLDU1, 100, 17);
+                                    count += 17;
+
+                                    // The '67' record - IMBE Voice 6 + Link Control
+                                    Buffer.BlockCopy(data, count, channel.netLDU1, 125, 17);
+                                    count += 17;
+
+                                    // The '68' record - IMBE Voice 7 + Link Control
+                                    Buffer.BlockCopy(data, count, channel.netLDU1, 150, 17);
+                                    count += 17;
+
+                                    // The '69' record - IMBE Voice 8 + Link Control
+                                    Buffer.BlockCopy(data, count, channel.netLDU1, 175, 17);
+                                    count += 17;
+
+                                    // The '6A' record - IMBE Voice 9 + Low Speed Data
+                                    Buffer.BlockCopy(data, count, channel.netLDU1, 200, 16);
+                                    count += 16;
+
+                                    // decode 9 IMBE codewords into PCM samples
+                                    P25DecodeAudioFrame(channel.netLDU1, e, handler, channel, isEmergency);
+                                }
+                            }
+                            break;
+                        case P25DUID.LDU2:
+                            {
+                                // The '6B', '6C', '6D', '6E', '6F', '70', '71', '72', '73' records are LDU2
+                                if ((data[0U] == 0x6BU) && (data[22U] == 0x6CU) &&
+                                    (data[36U] == 0x6DU) && (data[53U] == 0x6EU) &&
+                                    (data[70U] == 0x6FU) && (data[87U] == 0x70U) &&
+                                    (data[104U] == 0x71U) && (data[121U] == 0x72U) &&
+                                    (data[138U] == 0x73U))
+                                {
+                                    // The '6B' record - IMBE Voice 10
+                                    Buffer.BlockCopy(data, count, channel.netLDU2, 0, 22);
+                                    count += 22;
+
+                                    // The '6C' record - IMBE Voice 11
+                                    Buffer.BlockCopy(data, count, channel.netLDU2, 25, 14);
+                                    count += 14;
+
+                                    // The '6D' record - IMBE Voice 12 + Encryption Sync
+                                    Buffer.BlockCopy(data, count, channel.netLDU2, 50, 17);
+                                    newMI[0] = data[count + 1];
+                                    newMI[1] = data[count + 2];
+                                    newMI[2] = data[count + 3];
+                                    count += 17;
+
+                                    // The '6E' record - IMBE Voice 13 + Encryption Sync
+                                    Buffer.BlockCopy(data, count, channel.netLDU2, 75, 17);
+                                    newMI[3] = data[count + 1];
+                                    newMI[4] = data[count + 2];
+                                    newMI[5] = data[count + 3];
+                                    count += 17;
+
+                                    // The '6F' record - IMBE Voice 14 + Encryption Sync
+                                    Buffer.BlockCopy(data, count, channel.netLDU2, 100, 17);
+                                    newMI[6] = data[count + 1];
+                                    newMI[7] = data[count + 2];
+                                    newMI[8] = data[count + 3];
+                                    count += 17;
+
+                                    // The '70' record - IMBE Voice 15 + Encryption Sync
+                                    Buffer.BlockCopy(data, count, channel.netLDU2, 125, 17);
+                                    channel.algId = data[count + 1];                                    // Algorithm ID
+                                    channel.kId = (ushort)((data[count + 2] << 8) | data[count + 3]);   // Key ID
+                                    count += 17;
+
+                                    // The '71' record - IMBE Voice 16 + Encryption Sync
+                                    Buffer.BlockCopy(data, count, channel.netLDU2, 150, 17);
+                                    count += 17;
+
+                                    // The '72' record - IMBE Voice 17 + Encryption Sync
+                                    Buffer.BlockCopy(data, count, channel.netLDU2, 175, 17);
+                                    count += 17;
+
+                                    // The '73' record - IMBE Voice 18 + Low Speed Data
+                                    Buffer.BlockCopy(data, count, channel.netLDU2, 200, 16);
+                                    count += 16;
+
+                                    if (channel.p25Errs > 0) // temp, need to actually get errors I guess
+                                        P25Crypto.CycleP25Lfsr(channel.mi);
+                                    else
+                                        Array.Copy(newMI, channel.mi, P25Defines.P25_MI_LENGTH);
+
+                                    // decode 9 IMBE codewords into PCM samples
+                                    P25DecodeAudioFrame(channel.netLDU2, e, handler, channel, isEmergency, P25Crypto.FrameType.LDU2);
+                                }
+                            }
+                            break;
+                    }
+
+                    if (channel.mi != null)
+                        channel.crypter.Prepare(channel.algId, channel.kId, P25Crypto.ProtocolType.P25Phase1, channel.mi);
+
+                    slot.RxRFS = e.SrcId;
+                    slot.RxType = e.FrameType;
+                    slot.RxTGId = e.DstId;
+                    slot.RxTime = pktTime;
+                    slot.RxStreamId = e.StreamId;
+
+                }
+            });
+        }
+
+        private void CallHist_Click(object sender, RoutedEventArgs e)
+        {
+            callHistoryWindow.Show();
+        }
+    }
+}

From b871262180ad816c42b8471fc4753844b73c836f Mon Sep 17 00:00:00 2001
From: Firav <firavv@gmail.com>
Date: Tue, 11 Nov 2025 12:44:45 -0500
Subject: [PATCH 05/13] add hotkeys logic to main and settings managers

---
 WhackerLinkConsoleV2/MainWindow.xaml.cs | 243 ++++++++++++++++++++++++
 WhackerLinkConsoleV2/SettingsManager.cs |   7 +
 2 files changed, 250 insertions(+)

diff --git a/WhackerLinkConsoleV2/MainWindow.xaml.cs b/WhackerLinkConsoleV2/MainWindow.xaml.cs
index a4c1447..a00522d 100644
--- a/WhackerLinkConsoleV2/MainWindow.xaml.cs
+++ b/WhackerLinkConsoleV2/MainWindow.xaml.cs
@@ -70,6 +70,11 @@ public partial class MainWindow : Window
         private FlashingBackgroundManager _flashingManager;
         private WaveFilePlaybackManager _emergencyAlertPlayback;
         private WebSocketManager _webSocketManager = new WebSocketManager();
+        private ChannelKeybindingManager _channelKeybindingManager = new ChannelKeybindingManager();
+        private GlobalHotKeyManager _globalHotKeyManager;
+        private ChannelHotKeyManager _channelHotKeyManager;
+        private int _globalPttHotKeyId = -1;
+        private string _currentCodeplugIdentifier;
 
         private ChannelBox playbackChannelBox;
 
@@ -457,6 +462,9 @@ private void GenerateChannelWidgets()
             //    offsetY += 106;
             //}
 
+            // Initialize channel hotkeys after channels are created
+            InitializeChannelHotkeys();
+
             AdjustCanvasHeight();
         }
 
@@ -618,6 +626,241 @@ private void AudioSettings_Click(object sender, RoutedEventArgs e)
             audioSettingsWindow.ShowDialog();
         }
 
+        private void ConfigurePttKeybindings_Click(object sender, RoutedEventArgs e)
+        {
+            if (Codeplug == null)
+            {
+                MessageBox.Show("Please load a codeplug first before configuring PTT keybindings.", "No Codeplug Loaded", MessageBoxButton.OK, MessageBoxImage.Information);
+                return;
+            }
+
+            var configWindow = new KeybindingConfigWindow(
+                _settingsManager,
+                _channelKeybindingManager,
+                Codeplug,
+                _settingsManager.LastCodeplugPath
+            );
+
+            configWindow.Owner = this;
+            configWindow.ShowDialog();
+
+            // Reinitialize hotkeys after configuration changes
+            InitializeGlobalHotkeys();
+            if (Codeplug != null)
+            {
+                InitializeChannelHotkeys();
+            }
+        }
+
+        private void InitializeGlobalHotkeys()
+        {
+            try
+            {
+                // Initialize the hotkey manager if not already done
+                if (_globalHotKeyManager == null)
+                {
+                    _globalHotKeyManager = new GlobalHotKeyManager();
+                    _globalHotKeyManager.Initialize(this);
+                }
+
+                // Unregister old hotkey
+                if (_globalPttHotKeyId != -1)
+                    _globalHotKeyManager.UnregisterHotKey(_globalPttHotKeyId);
+
+                // Register Global PTT hotkey
+                if (_settingsManager.EnableGlobalPttHotkey && !string.IsNullOrWhiteSpace(_settingsManager.GlobalPttKeybind))
+                {
+                    if (KeybindingParser.TryParseKeybinding(_settingsManager.GlobalPttKeybind, out var globalModifiers, out var globalKey))
+                    {
+                        _globalPttHotKeyId = _globalHotKeyManager.RegisterHotKey(
+                            globalModifiers,
+                            globalKey,
+                            OnGlobalPttHotKeyDown,
+                            OnGlobalPttHotKeyUp
+                        );
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"ERROR: Failed to initialize global hotkeys: {ex.Message}");
+            }
+        }
+
+        private void InitializeChannelHotkeys()
+        {
+            try
+            {
+                _currentCodeplugIdentifier = ChannelKeybindingManager.GenerateCodeplugIdentifier(_settingsManager.LastCodeplugPath);
+
+                // Make sure global hotkey manager is initialized first
+                if (_globalHotKeyManager == null)
+                {
+                    InitializeGlobalHotkeys();
+                }
+
+                if (_channelHotKeyManager == null)
+                {
+                    _channelHotKeyManager = new ChannelHotKeyManager(
+                        _globalHotKeyManager,
+                        _channelKeybindingManager,
+                        OnChannelHotKeyTriggered
+                    );
+                }
+
+                var allChannels = ChannelsCanvas.Children.OfType<ChannelBox>().ToList();
+                _channelHotKeyManager.InitializeChannelHotkeys(_currentCodeplugIdentifier, allChannels);
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"ERROR: Failed to initialize channel hotkeys: {ex.Message}");
+            }
+        }
+
+        private void OnGlobalPttHotKeyDown()
+        {
+            Dispatcher.Invoke(() =>
+            {
+                if (!globalPttState)
+                {
+                    globalPttState = true;
+                    ActivateGlobalPtt();
+                }
+            });
+        }
+
+        private void OnGlobalPttHotKeyUp()
+        {
+            Dispatcher.Invoke(() =>
+            {
+                if (globalPttState)
+                {
+                    globalPttState = false;
+                    ReleaseGlobalPtt();
+                }
+            });
+        }
+
+        private void OnChannelHotKeyTriggered(ChannelBox channel, bool isPressed)
+        {
+            Dispatcher.Invoke(() =>
+            {
+                if (channel != null)
+                {
+                    if (isPressed && !channel.PttState)
+                    {
+                        channel.PttState = true;
+                        ChannelBox_PTTButtonClicked(channel, channel);
+                    }
+                    else if (!isPressed && channel.PttState)
+                    {
+                        channel.PttState = false;
+                        ChannelBox_PTTButtonClicked(channel, channel);
+                    }
+                }
+            });
+        }
+
+        private async void ActivateGlobalPtt()
+        {
+            foreach (ChannelBox channel in _selectedChannelsManager.GetSelectedChannels())
+            {
+                if (channel.SystemName == PLAYBACKSYS || channel.ChannelName == PLAYBACKCHNAME || channel.DstId == PLAYBACKTG)
+                    continue;
+
+                Codeplug.System system = Codeplug.GetSystemForChannel(channel.ChannelName);
+                Codeplug.Channel cpgChannel = Codeplug.GetChannelByName(channel.ChannelName);
+
+                if (!system.IsDvm)
+                {
+                    IPeer handler = _webSocketManager.GetWebSocketHandler(system.Name);
+
+                    if (!channel.IsSelected)
+                        continue;
+
+                    Dispatcher.Invoke(() =>
+                    {
+                        btnGlobalPtt.Background = channel.redGradient;
+                    });
+
+                    GRP_VCH_REQ request = new GRP_VCH_REQ
+                    {
+                        SrcId = system.Rid,
+                        DstId = cpgChannel.Tgid,
+                        Site = system.Site
+                    };
+
+                    channel.PttState = true;
+
+                    handler.SendMessage(request.GetData());
+                }
+                else
+                {
+                    PeerSystem handler = _fneSystemManager.GetFneSystem(system.Name);
+
+                    channel.txStreamId = handler.NewStreamId();
+
+                    Dispatcher.Invoke(() =>
+                    {
+                        btnGlobalPtt.Background = channel.redGradient;
+                        channel.PttState = true;
+                    });
+
+                    handler.SendP25TDU(UInt32.Parse(system.Rid), UInt32.Parse(cpgChannel.Tgid), true);
+                }
+            }
+        }
+
+        private async void ReleaseGlobalPtt()
+        {
+            await Task.Delay(500);
+
+            foreach (ChannelBox channel in _selectedChannelsManager.GetSelectedChannels())
+            {
+                if (channel.SystemName == PLAYBACKSYS || channel.ChannelName == PLAYBACKCHNAME || channel.DstId == PLAYBACKTG)
+                    continue;
+
+                Codeplug.System system = Codeplug.GetSystemForChannel(channel.ChannelName);
+                Codeplug.Channel cpgChannel = Codeplug.GetChannelByName(channel.ChannelName);
+
+                if (!system.IsDvm)
+                {
+                    IPeer handler = _webSocketManager.GetWebSocketHandler(system.Name);
+
+                    if (!channel.IsSelected)
+                        continue;
+
+                    Dispatcher.Invoke(() =>
+                    {
+                        btnGlobalPtt.Background = channel.grayGradient;
+                    });
+
+                    GRP_VCH_RLS release = new GRP_VCH_RLS
+                    {
+                        SrcId = system.Rid,
+                        DstId = cpgChannel.Tgid,
+                        Site = system.Site
+                    };
+
+                    channel.PttState = false;
+
+                    handler.SendMessage(release.GetData());
+                }
+                else
+                {
+                    PeerSystem handler = _fneSystemManager.GetFneSystem(system.Name);
+
+                    Dispatcher.Invoke(() =>
+                    {
+                        btnGlobalPtt.Background = channel.grayGradient;
+                        channel.PttState = false;
+                    });
+
+                    handler.SendP25TDU(UInt32.Parse(system.Rid), UInt32.Parse(cpgChannel.Tgid), false);
+                }
+            }
+        }
+
         private void P25Page_Click(object sender, RoutedEventArgs e)
         {
             DigitalPageWindow pageWindow = new DigitalPageWindow(Codeplug.Systems);
diff --git a/WhackerLinkConsoleV2/SettingsManager.cs b/WhackerLinkConsoleV2/SettingsManager.cs
index 96690b9..1736e7d 100644
--- a/WhackerLinkConsoleV2/SettingsManager.cs
+++ b/WhackerLinkConsoleV2/SettingsManager.cs
@@ -39,6 +39,11 @@ public class SettingsManager
         public Dictionary<string, ChannelPosition> AlertTonePositions { get; set; } = new Dictionary<string, ChannelPosition>();
         public Dictionary<string, int> ChannelOutputDevices { get; set; } = new Dictionary<string, int>();
 
+        // Hotkey bindings for global PTT
+        // Supports both single-key (e.g., "T", "P") and dual-key (e.g., "Ctrl+T", "Ctrl+P")
+        public string GlobalPttKeybind { get; set; } = "Ctrl+T";          // Global PTT across all selected channels
+        public bool EnableGlobalPttHotkey { get; set; } = true;
+
         public void LoadSettings()
         {
             if (!File.Exists(SettingsFilePath)) return;
@@ -59,6 +64,8 @@ public void LoadSettings()
                     AlertToneFilePaths = loadedSettings.AlertToneFilePaths ?? new List<string>();
                     AlertTonePositions = loadedSettings.AlertTonePositions ?? new Dictionary<string, ChannelPosition>();
                     ChannelOutputDevices = loadedSettings.ChannelOutputDevices ?? new Dictionary<string, int>();
+                    GlobalPttKeybind = loadedSettings.GlobalPttKeybind ?? "Ctrl+T";
+                    EnableGlobalPttHotkey = loadedSettings.EnableGlobalPttHotkey;
                 }
             }
             catch (Exception ex)

From 0dc74d76b2085ccd5adc905753b6eb30324f09f0 Mon Sep 17 00:00:00 2001
From: Firav <firavv@gmail.com>
Date: Tue, 11 Nov 2025 12:45:02 -0500
Subject: [PATCH 06/13] attempt to fix some fuckery with the program not
 wanting to properly shut down

---
 WhackerLinkConsoleV2/MainWindow.xaml.cs | 99 ++++++++++++++++++++++++-
 1 file changed, 97 insertions(+), 2 deletions(-)

diff --git a/WhackerLinkConsoleV2/MainWindow.xaml.cs b/WhackerLinkConsoleV2/MainWindow.xaml.cs
index a00522d..4b85582 100644
--- a/WhackerLinkConsoleV2/MainWindow.xaml.cs
+++ b/WhackerLinkConsoleV2/MainWindow.xaml.cs
@@ -16,6 +16,7 @@
 * 
 * Copyright (C) 2024-2025 Caleb, K4PHP
 * Copyright (C) 2025 J. Dean
+* Copyright (C) 2025 Firav (firavdev@gmail.com)
 * 
 */
 
@@ -87,7 +88,7 @@ public partial class MainWindow : Window
         private readonly WaveInEvent _waveIn;
         private readonly AudioManager _audioManager;
 
-        private static System.Timers.Timer _channelHoldTimer;
+        private System.Timers.Timer _channelHoldTimer;
 
         private Dictionary<string, SlotStatus> systemStatuses = new Dictionary<string, SlotStatus>();
         private FneSystemManager _fneSystemManager = new FneSystemManager();
@@ -117,6 +118,7 @@ public MainWindow()
 
             InitializeComponent();
             _settingsManager.LoadSettings();
+            _channelKeybindingManager.LoadKeybindings();
             _selectedChannelsManager = new SelectedChannelsManager();
             _flashingManager = new FlashingBackgroundManager(null, ChannelsCanvas, null, this);
             _emergencyAlertPlayback = new WaveFilePlaybackManager(System.IO.Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "emergency.wav"));
@@ -139,6 +141,7 @@ public MainWindow()
 
             _selectedChannelsManager.SelectedChannelsChanged += SelectedChannelsChanged;
             Loaded += MainWindow_Loaded;
+            Loaded += (s, e) => InitializeGlobalHotkeys();
         }
 
         private void OpenCodeplug_Click(object sender, RoutedEventArgs e)
@@ -1773,7 +1776,6 @@ protected override void OnClosing(System.ComponentModel.CancelEventArgs e)
         {
             _settingsManager.SaveSettings();
             base.OnClosing(e);
-            Application.Current.Shutdown();
         }
 
         private void ClearEmergency_Click(object sender, RoutedEventArgs e)
@@ -2569,5 +2571,98 @@ private void CallHist_Click(object sender, RoutedEventArgs e)
         {
             callHistoryWindow.Show();
         }
+
+        private void MainWindow_OnClosed(object sender, EventArgs e)
+        {
+            Console.WriteLine("=== Application Shutdown Started ===");
+
+            // Stop and dispose timers FIRST to prevent any new operations
+            try
+            {
+                Console.WriteLine("Stopping timers...");
+                _channelHoldTimer?.Stop();
+                _channelHoldTimer?.Dispose();
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"Error disposing timer: {ex.Message}");
+            }
+
+            // Cleanup hotkeys early
+            try
+            {
+                _globalHotKeyManager?.UnregisterAllHotKeys();
+                _channelHotKeyManager?.UnregisterAllChannelHotkeys();
+                _globalHotKeyManager?.Dispose();
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"Error disposing hotkeys: {ex.Message}");
+            }
+
+            // Disconnect all WebSocket connections
+            try
+            {
+                Console.WriteLine("Disconnecting WebSocket connections...");
+                _webSocketManager?.ClearAllWebSocketHandlers();
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"Error disconnecting websockets: {ex.Message}");
+            }
+
+            // Stop all FNE systems
+            try
+            {
+                Console.WriteLine("Stopping FNE systems...");
+                _fneSystemManager?.ClearAll();
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"Error stopping FNE systems: {ex.Message}");
+            }
+
+            // Give connections a moment to close gracefully
+            Console.WriteLine("Waiting for connections to close...");
+            System.Threading.Thread.Sleep(1000);
+
+            // Stop and dispose audio recording
+            try
+            {
+                Console.WriteLine("Stopping audio recording...");
+                _waveIn?.StopRecording();
+                _waveIn?.Dispose();
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"Error disposing audio: {ex.Message}");
+            }
+
+            // Stop emergency alert playback
+            try
+            {
+                _emergencyAlertPlayback?.Stop();
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"Error stopping emergency playback: {ex.Message}");
+            }
+
+            // Save settings
+            try
+            {
+                _settingsManager?.SaveSettings();
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"Error saving settings: {ex.Message}");
+            }
+
+            Console.WriteLine("Cleanup complete. Terminating process...");
+            
+            // Force immediate process termination
+            // This is necessary because background threads from WebSocket/FNE may not terminate cleanly
+            Environment.Exit(0);
+        }
     }
 }

From cd04a5884a505d0405ac0da6a3c82fb459b4791a Mon Sep 17 00:00:00 2001
From: Firav <firavv@gmail.com>
Date: Thu, 13 Nov 2025 14:34:00 -0500
Subject: [PATCH 07/13] use relative paths for audio files instead of root dir

---
 WhackerLinkConsoleV2/MainWindow.xaml.cs | 13 ++++++++-----
 1 file changed, 8 insertions(+), 5 deletions(-)

diff --git a/WhackerLinkConsoleV2/MainWindow.xaml.cs b/WhackerLinkConsoleV2/MainWindow.xaml.cs
index 4b85582..7bdcb2f 100644
--- a/WhackerLinkConsoleV2/MainWindow.xaml.cs
+++ b/WhackerLinkConsoleV2/MainWindow.xaml.cs
@@ -1754,7 +1754,7 @@ private async void OnHoldTimerElapsed(object sender, ElapsedEventArgs e)
 
                         await Task.Delay(1000);
 
-                        SendAlertTone("hold.wav", true);
+                        SendAlertTone(System.IO.Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Audio", "hold.wav"), true);
                         // });
                     }
                 } else
@@ -1766,7 +1766,7 @@ private async void OnHoldTimerElapsed(object sender, ElapsedEventArgs e)
                         handler.SendP25TDU(UInt32.Parse(system.Rid), UInt32.Parse(cpgChannel.Tgid), true);
                         await Task.Delay(1000);
 
-                        SendAlertTone("hold.wav", true);
+                        SendAlertTone(System.IO.Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Audio", "hold.wav"), true);
                     }
                 }
             }
@@ -1792,7 +1792,8 @@ private void ClearEmergency_Click(object sender, RoutedEventArgs e)
         private void btnAlert1_Click(object sender, RoutedEventArgs e)
         {
             Dispatcher.Invoke(() => {
-                SendAlertTone("alert1.wav");
+                string alertPath = System.IO.Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Audio", "alert1.wav");
+                SendAlertTone(alertPath);
             });
         }
 
@@ -1800,7 +1801,8 @@ private void btnAlert2_Click(object sender, RoutedEventArgs e)
         {
             Dispatcher.Invoke(() =>
             {
-                SendAlertTone("alert2.wav");
+                string alertPath = System.IO.Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Audio", "alert2.wav");
+                SendAlertTone(alertPath);
             });
         }
 
@@ -1808,7 +1810,8 @@ private void btnAlert3_Click(object sender, RoutedEventArgs e)
         {
             Dispatcher.Invoke(() =>
             {
-                SendAlertTone("alert3.wav");
+                string alertPath = System.IO.Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Audio", "alert3.wav");
+                SendAlertTone(alertPath);
             });
         }
 

From 319ef426f11a34f03187247cbe53b108a17e1ff7 Mon Sep 17 00:00:00 2001
From: Firav <firavv@gmail.com>
Date: Wed, 10 Dec 2025 10:47:18 -0500
Subject: [PATCH 08/13] add new icon and its assets. closes #2.

---
 WhackerLinkConsoleV2/Assets/app-icon.ico        | Bin 0 -> 15406 bytes
 .../Assets/whackerlink-logo-icon.png            | Bin 0 -> 33975 bytes
 WhackerLinkConsoleV2/MainWindow.xaml            |   1 +
 .../WhackerLinkConsoleV2.csproj                 |   3 +++
 4 files changed, 4 insertions(+)
 create mode 100644 WhackerLinkConsoleV2/Assets/app-icon.ico
 create mode 100644 WhackerLinkConsoleV2/Assets/whackerlink-logo-icon.png

diff --git a/WhackerLinkConsoleV2/Assets/app-icon.ico b/WhackerLinkConsoleV2/Assets/app-icon.ico
new file mode 100644
index 0000000000000000000000000000000000000000..59d61f393e59c04a468d907fa5480d02486f9e14
GIT binary patch
literal 15406
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
MzyC<!|3(7;0}UZA`v3p{

literal 0
HcmV?d00001

diff --git a/WhackerLinkConsoleV2/Assets/whackerlink-logo-icon.png b/WhackerLinkConsoleV2/Assets/whackerlink-logo-icon.png
new file mode 100644
index 0000000000000000000000000000000000000000..ffbc01f937c6126f7457d73561afb6c88cdae280
GIT binary patch
literal 33975
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
bZ#ew_))+dzAGB)y00000NkvXXu0mjfAc;ic

literal 0
HcmV?d00001

diff --git a/WhackerLinkConsoleV2/MainWindow.xaml b/WhackerLinkConsoleV2/MainWindow.xaml
index 538c4b9..fbb0dcc 100644
--- a/WhackerLinkConsoleV2/MainWindow.xaml
+++ b/WhackerLinkConsoleV2/MainWindow.xaml
@@ -3,6 +3,7 @@
         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
         xmlns:local="clr-namespace:WhackerLinkConsoleV2.Controls"
         Title="WhackerLinkConsoleV2" Height="600" Width="1000" Background="#FFF2F2F2"
+        Icon="/Assets/whackerlink-logo-icon.png"
         Closed="MainWindow_OnClosed">
     <Grid Background="#FFF2F2F2">
         <Grid.ColumnDefinitions>
diff --git a/WhackerLinkConsoleV2/WhackerLinkConsoleV2.csproj b/WhackerLinkConsoleV2/WhackerLinkConsoleV2.csproj
index 5441dd9..adbe062 100644
--- a/WhackerLinkConsoleV2/WhackerLinkConsoleV2.csproj
+++ b/WhackerLinkConsoleV2/WhackerLinkConsoleV2.csproj
@@ -9,6 +9,7 @@
     <Platforms>AnyCPU;x64;x86</Platforms>
     <Configurations>Debug;Release;WIN32</Configurations>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <ApplicationIcon>Assets\app-icon.ico</ApplicationIcon>
   </PropertyGroup>
 
   <ItemGroup>
@@ -38,6 +39,7 @@
     <Resource Include="Assets\alerttone.png" />
     <Resource Include="Assets\alerttone2.png" />
     <Resource Include="Assets\audio.png" />
+    <Resource Include="Assets\app-icon.ico" />
   </ItemGroup>
 
   <ItemGroup>
@@ -69,6 +71,7 @@
     <Resource Include="Assets\pageselect.png" />
     <Resource Include="Assets\pttselect.png" />
     <Resource Include="Assets\whackerlink-logo.png" />
+    <Resource Include="Assets\whackerlink-logo-icon.png" />
     <Resource Include="Assets\WhackerLinkLogoV2.png" />
     <Resource Include="Assets\WhackerLinkLogoV4.png" />
   </ItemGroup>

From 8c5a6d53e30471b4a48a9df10d3cda56e665413f Mon Sep 17 00:00:00 2001
From: Firav <firavv@gmail.com>
Date: Wed, 10 Dec 2025 10:49:27 -0500
Subject: [PATCH 09/13] - allow clearing of channel keybinds - improve keybind
 application functionality - prohibit keys from being pressed during keybind
 management - closes #1

---
 WhackerLinkConsoleV2/ChannelHotKeyManager.cs  | 13 ++-
 .../KeybindingConfigWindow.xaml.cs            | 82 ++++++++++++++++++-
 WhackerLinkConsoleV2/MainWindow.xaml.cs       | 54 ++++++++++--
 3 files changed, 134 insertions(+), 15 deletions(-)

diff --git a/WhackerLinkConsoleV2/ChannelHotKeyManager.cs b/WhackerLinkConsoleV2/ChannelHotKeyManager.cs
index 1e1630d..ae3c7df 100644
--- a/WhackerLinkConsoleV2/ChannelHotKeyManager.cs
+++ b/WhackerLinkConsoleV2/ChannelHotKeyManager.cs
@@ -52,13 +52,12 @@ public ChannelHotKeyManager(GlobalHotKeyManager globalHotKeyManager, ChannelKeyb
         /// </summary>
         public void InitializeChannelHotkeys(string codeplugIdentifier, List<ChannelBox> channels)
         {
-            // Unregister old hotkeys if codeplug changed
-            if (_currentCodeplugIdentifier != codeplugIdentifier)
-            {
-                UnregisterAllChannelHotkeys();
-                _currentCodeplugIdentifier = codeplugIdentifier;
-            }
-
+            // Always unregister all existing channel hotkeys first to ensure 
+            // cleared keybindings are properly removed
+            UnregisterAllChannelHotkeys();
+            
+            // Update current codeplug identifier
+            _currentCodeplugIdentifier = codeplugIdentifier;
             _allChannels = channels;
 
             // Register hotkeys for channels that have keybindings
diff --git a/WhackerLinkConsoleV2/KeybindingConfigWindow.xaml.cs b/WhackerLinkConsoleV2/KeybindingConfigWindow.xaml.cs
index 1afb635..6670fdd 100644
--- a/WhackerLinkConsoleV2/KeybindingConfigWindow.xaml.cs
+++ b/WhackerLinkConsoleV2/KeybindingConfigWindow.xaml.cs
@@ -35,20 +35,30 @@ public partial class KeybindingConfigWindow : Window
         private ChannelKeybindingManager _channelKeybindingManager;
         private Codeplug _codeplug;
         private string _codeplugIdentifier;
+        private MainWindow _mainWindow;
 
         private bool _recordingGlobalPtt = false;
         private Dictionary<string, TextBox> _channelKeybindingControls = new Dictionary<string, TextBox>();
 
-        public KeybindingConfigWindow(SettingsManager settingsManager, ChannelKeybindingManager channelKeybindingManager, Codeplug codeplug, string codeplugFilePath)
+        /// <summary>
+        /// Gets whether keybindings were successfully applied and should take immediate effect
+        /// </summary>
+        public bool KeybindingsApplied { get; private set; } = false;
+
+        public KeybindingConfigWindow(SettingsManager settingsManager, ChannelKeybindingManager channelKeybindingManager, Codeplug codeplug, string codeplugFilePath, MainWindow mainWindow = null)
         {
             InitializeComponent();
             _settingsManager = settingsManager;
             _channelKeybindingManager = channelKeybindingManager;
             _codeplug = codeplug;
             _codeplugIdentifier = ChannelKeybindingManager.GenerateCodeplugIdentifier(codeplugFilePath);
+            _mainWindow = mainWindow;
 
             LoadSettings();
             GenerateChannelControls();
+            
+            // Suspend all hotkeys while this window is open to prevent background activation
+            SuspendMainWindowHotkeys();
         }
 
         private void LoadSettings()
@@ -104,6 +114,7 @@ private void GenerateChannelControls()
                 grid.ColumnDefinitions.Add(new ColumnDefinition { Width = new GridLength(150) });
                 grid.ColumnDefinitions.Add(new ColumnDefinition { Width = new GridLength(1, GridUnitType.Star) });
                 grid.ColumnDefinitions.Add(new ColumnDefinition { Width = GridLength.Auto });
+                grid.ColumnDefinitions.Add(new ColumnDefinition { Width = GridLength.Auto });
 
                 // Channel name
                 var channelNameText = new TextBlock
@@ -134,12 +145,24 @@ private void GenerateChannelControls()
                 {
                     Content = "Record",
                     Width = 80,
-                    Tag = channel.Name
+                    Tag = channel.Name,
+                    Margin = new Thickness(0, 0, 10, 0)
                 };
                 recordButton.Click += (s, e) => RecordChannelKeybind_Click(channel.Name);
                 Grid.SetColumn(recordButton, 2);
                 grid.Children.Add(recordButton);
 
+                // Clear button
+                var clearButton = new Button
+                {
+                    Content = "Clear",
+                    Width = 80,
+                    Tag = channel.Name
+                };
+                clearButton.Click += (s, e) => ClearChannelKeybind_Click(channel.Name);
+                Grid.SetColumn(clearButton, 3);
+                grid.Children.Add(clearButton);
+
                 ChannelKeybindingsPanel.Children.Add(grid);
             }
         }
@@ -163,9 +186,29 @@ private void RecordChannelKeybind_Click(string channelName)
             Focus();
         }
 
+        private void ClearChannelKeybind_Click(string channelName)
+        {
+            if (!_channelKeybindingControls.TryGetValue(channelName, out var textBox))
+                return;
+
+            textBox.Text = "";
+            // Reset any recording state for this channel
+            if (Tag is string tag && tag == $"recording_{channelName}")
+            {
+                Tag = null;
+            }
+        }
+
         private void ClearGlobalPtt_Click(object sender, RoutedEventArgs e)
         {
             GlobalPttKeybindDisplay.Text = "";
+            // Reset global PTT recording state if active
+            if (_recordingGlobalPtt)
+            {
+                _recordingGlobalPtt = false;
+                RecordGlobalPttButton.Content = "Record";
+                RecordGlobalPttButton.IsEnabled = true;
+            }
         }
 
         protected override void OnPreviewKeyDown(KeyEventArgs e)
@@ -253,7 +296,9 @@ private void Apply_Click(object sender, RoutedEventArgs e)
                 }
             }
 
-            MessageBox.Show("Keybindings saved successfully! Restart the application or reload the codeplug to apply changes.", "Success", MessageBoxButton.OK, MessageBoxImage.Information);
+            KeybindingsApplied = true;
+
+            MessageBox.Show("Keybindings saved and applied successfully!", "Success", MessageBoxButton.OK, MessageBoxImage.Information);
             Close();
         }
 
@@ -261,5 +306,36 @@ private void Close_Click(object sender, RoutedEventArgs e)
         {
             Close();
         }
+
+        private void SuspendMainWindowHotkeys()
+        {
+            try
+            {
+                _mainWindow?.SuspendHotkeys();
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"WARNING: Failed to suspend main window hotkeys: {ex.Message}");
+            }
+        }
+
+        private void ResumeMainWindowHotkeys()
+        {
+            try
+            {
+                _mainWindow?.ResumeHotkeys();
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"WARNING: Failed to resume main window hotkeys: {ex.Message}");
+            }
+        }
+
+        protected override void OnClosed(EventArgs e)
+        {
+            // Always resume hotkeys when the window is closed, regardless of how it was closed
+            ResumeMainWindowHotkeys();
+            base.OnClosed(e);
+        }
     }
 }
diff --git a/WhackerLinkConsoleV2/MainWindow.xaml.cs b/WhackerLinkConsoleV2/MainWindow.xaml.cs
index 7bdcb2f..96c4fca 100644
--- a/WhackerLinkConsoleV2/MainWindow.xaml.cs
+++ b/WhackerLinkConsoleV2/MainWindow.xaml.cs
@@ -641,17 +641,21 @@ private void ConfigurePttKeybindings_Click(object sender, RoutedEventArgs e)
                 _settingsManager,
                 _channelKeybindingManager,
                 Codeplug,
-                _settingsManager.LastCodeplugPath
+                _settingsManager.LastCodeplugPath,
+                this
             );
 
             configWindow.Owner = this;
             configWindow.ShowDialog();
 
-            // Reinitialize hotkeys after configuration changes
-            InitializeGlobalHotkeys();
-            if (Codeplug != null)
+            // Reinitialize hotkeys only if configuration changes were applied
+            if (configWindow.KeybindingsApplied)
             {
-                InitializeChannelHotkeys();
+                InitializeGlobalHotkeys();
+                if (Codeplug != null)
+                {
+                    InitializeChannelHotkeys();
+                }
             }
         }
 
@@ -668,7 +672,10 @@ private void InitializeGlobalHotkeys()
 
                 // Unregister old hotkey
                 if (_globalPttHotKeyId != -1)
+                {
                     _globalHotKeyManager.UnregisterHotKey(_globalPttHotKeyId);
+                    _globalPttHotKeyId = -1;
+                }
 
                 // Register Global PTT hotkey
                 if (_settingsManager.EnableGlobalPttHotkey && !string.IsNullOrWhiteSpace(_settingsManager.GlobalPttKeybind))
@@ -720,6 +727,43 @@ private void InitializeChannelHotkeys()
             }
         }
 
+        /// <summary>
+        /// Temporarily suspends all hotkeys (used when configuration window is open)
+        /// </summary>
+        public void SuspendHotkeys()
+        {
+            try
+            {
+                _globalHotKeyManager?.UnregisterAllHotKeys();
+                _channelHotKeyManager?.UnregisterAllChannelHotkeys();
+                Console.WriteLine("Hotkeys suspended");
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"ERROR: Failed to suspend hotkeys: {ex.Message}");
+            }
+        }
+
+        /// <summary>
+        /// Resumes all hotkeys after suspension
+        /// </summary>
+        public void ResumeHotkeys()
+        {
+            try
+            {
+                InitializeGlobalHotkeys();
+                if (Codeplug != null)
+                {
+                    InitializeChannelHotkeys();
+                }
+                Console.WriteLine("Hotkeys resumed");
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"ERROR: Failed to resume hotkeys: {ex.Message}");
+            }
+        }
+
         private void OnGlobalPttHotKeyDown()
         {
             Dispatcher.Invoke(() =>

From 8663736254d7dcca6fea2314079e477809a353f6 Mon Sep 17 00:00:00 2001
From: Firav <firavv@gmail.com>
Date: Wed, 10 Dec 2025 12:15:10 -0500
Subject: [PATCH 10/13] add keybinding for toggling channel connected status,
 refactor keybind page to accomodate for new category. closes #3

---
 WhackerLinkConsoleV2/ChannelBox.xaml.cs       |  20 ++
 WhackerLinkConsoleV2/ChannelHotKeyManager.cs  | 133 +++++++++++--
 .../ChannelKeybindingManager.cs               |  66 ++++++-
 .../KeybindingConfigWindow.xaml               |  58 ++++--
 .../KeybindingConfigWindow.xaml.cs            | 182 ++++++++++++++++--
 WhackerLinkConsoleV2/MainWindow.xaml          |   2 +-
 WhackerLinkConsoleV2/MainWindow.xaml.cs       |  18 +-
 7 files changed, 435 insertions(+), 44 deletions(-)

diff --git a/WhackerLinkConsoleV2/ChannelBox.xaml.cs b/WhackerLinkConsoleV2/ChannelBox.xaml.cs
index 18c9d2d..d08f74e 100644
--- a/WhackerLinkConsoleV2/ChannelBox.xaml.cs
+++ b/WhackerLinkConsoleV2/ChannelBox.xaml.cs
@@ -244,6 +244,26 @@ private void ChannelBox_MouseLeftButtonDown(object sender, MouseButtonEventArgs
             }
         }
 
+        /// <summary>
+        /// Toggles the channel selection state programmatically (used by keybinds)
+        /// </summary>
+        public void ToggleSelection()
+        {
+            if (IsEditMode) return;
+
+            IsSelected = !IsSelected;
+            Background = IsSelected ? (Brush)new BrushConverter().ConvertFrom("#FF0B004B") : Brushes.Gray;
+
+            if (IsSelected)
+            {
+                _selectedChannelsManager.AddSelectedChannel(this);
+            }
+            else
+            {
+                _selectedChannelsManager.RemoveSelectedChannel(this);
+            }
+        }
+
         private void UpdatePTTColor()
         {
             if (IsEditMode) return;
diff --git a/WhackerLinkConsoleV2/ChannelHotKeyManager.cs b/WhackerLinkConsoleV2/ChannelHotKeyManager.cs
index ae3c7df..fc6f9c9 100644
--- a/WhackerLinkConsoleV2/ChannelHotKeyManager.cs
+++ b/WhackerLinkConsoleV2/ChannelHotKeyManager.cs
@@ -28,23 +28,27 @@
 namespace WhackerLinkConsoleV2
 {
     /// <summary>
-    /// Manages per-channel PTT hotkey registrations and triggering
+    /// Manages per-channel PTT and toggle hotkey registrations and triggering
     /// </summary>
     public class ChannelHotKeyManager
     {
         private GlobalHotKeyManager _globalHotKeyManager;
         private ChannelKeybindingManager _channelKeybindingManager;
         private Dictionary<string, int> _channelHotKeyIds = new Dictionary<string, int>();
+        private Dictionary<string, int> _channelToggleHotKeyIds = new Dictionary<string, int>();
         private Dictionary<int, string> _hotKeyIdToChannelName = new Dictionary<int, string>();
+        private Dictionary<int, string> _toggleHotKeyIdToChannelName = new Dictionary<int, string>();
         private List<ChannelBox> _allChannels = new List<ChannelBox>();
         private string _currentCodeplugIdentifier;
         private Action<ChannelBox, bool> _onChannelPttTriggered;
+        private Action<ChannelBox> _onChannelToggleTriggered;
 
-        public ChannelHotKeyManager(GlobalHotKeyManager globalHotKeyManager, ChannelKeybindingManager channelKeybindingManager, Action<ChannelBox, bool> onChannelPttTriggered)
+        public ChannelHotKeyManager(GlobalHotKeyManager globalHotKeyManager, ChannelKeybindingManager channelKeybindingManager, Action<ChannelBox, bool> onChannelPttTriggered, Action<ChannelBox> onChannelToggleTriggered = null)
         {
             _globalHotKeyManager = globalHotKeyManager;
             _channelKeybindingManager = channelKeybindingManager;
             _onChannelPttTriggered = onChannelPttTriggered;
+            _onChannelToggleTriggered = onChannelToggleTriggered;
         }
 
         /// <summary>
@@ -60,22 +64,36 @@ public void InitializeChannelHotkeys(string codeplugIdentifier, List<ChannelBox>
             _currentCodeplugIdentifier = codeplugIdentifier;
             _allChannels = channels;
 
-            // Register hotkeys for channels that have keybindings
-            int registeredCount = 0;
+            // Register PTT hotkeys for channels that have PTT keybindings
+            int registeredPttCount = 0;
+            int registeredToggleCount = 0;
+            
             foreach (var channel in channels)
             {
-                var keybinding = _channelKeybindingManager.GetChannelKeybinding(codeplugIdentifier, channel.ChannelName);
-                
-                if (!string.IsNullOrWhiteSpace(keybinding))
+                // Register PTT hotkey
+                var pttKeybinding = _channelKeybindingManager.GetChannelKeybinding(codeplugIdentifier, channel.ChannelName);
+                if (!string.IsNullOrWhiteSpace(pttKeybinding))
+                {
+                    RegisterChannelHotkey(channel.ChannelName, pttKeybinding);
+                    registeredPttCount++;
+                }
+
+                // Register toggle hotkey
+                var toggleKeybinding = _channelKeybindingManager.GetChannelToggleKeybinding(codeplugIdentifier, channel.ChannelName);
+                if (!string.IsNullOrWhiteSpace(toggleKeybinding))
                 {
-                    RegisterChannelHotkey(channel.ChannelName, keybinding);
-                    registeredCount++;
+                    RegisterChannelToggleHotkey(channel.ChannelName, toggleKeybinding);
+                    registeredToggleCount++;
                 }
             }
             
-            if (registeredCount > 0)
+            if (registeredPttCount > 0)
             {
-                Console.WriteLine($"Registered {registeredCount} channel hotkey(s)");
+                Console.WriteLine($"Registered {registeredPttCount} channel PTT hotkey(s)");
+            }
+            if (registeredToggleCount > 0)
+            {
+                Console.WriteLine($"Registered {registeredToggleCount} channel toggle hotkey(s)");
             }
         }
 
@@ -125,16 +143,71 @@ private void RegisterChannelHotkey(string channelName, string keybinding)
             }
         }
 
+        /// <summary>
+        /// Registers a toggle hotkey for a specific channel
+        /// </summary>
+        private void RegisterChannelToggleHotkey(string channelName, string keybinding)
+        {
+            if (_globalHotKeyManager == null)
+            {
+                Console.WriteLine($"ERROR: GlobalHotKeyManager is null! Cannot register toggle hotkey for '{channelName}'");
+                return;
+            }
+
+            // Unregister old toggle hotkey if it exists
+            if (_channelToggleHotKeyIds.ContainsKey(channelName))
+            {
+                var oldHotKeyId = _channelToggleHotKeyIds[channelName];
+                _globalHotKeyManager.UnregisterHotKey(oldHotKeyId);
+                _channelToggleHotKeyIds.Remove(channelName);
+                _toggleHotKeyIdToChannelName.Remove(oldHotKeyId);
+            }
+
+            // Parse the keybinding
+            if (!KeybindingParser.TryParseKeybinding(keybinding, out var modifiers, out var key))
+            {
+                Console.WriteLine($"ERROR: Failed to parse toggle keybinding '{keybinding}' for channel '{channelName}'");
+                return;
+            }
+
+            // Register with global hotkey manager (toggle only needs key down event)
+            var hotKeyId = _globalHotKeyManager.RegisterHotKey(
+                modifiers,
+                key,
+                () => OnChannelToggleHotKeyDown(channelName),
+                null // No key up action needed for toggle
+            );
+
+            if (hotKeyId != -1)
+            {
+                _channelToggleHotKeyIds[channelName] = hotKeyId;
+                _toggleHotKeyIdToChannelName[hotKeyId] = channelName;
+            }
+            else
+            {
+                Console.WriteLine($"Failed to register toggle hotkey '{keybinding}' for channel '{channelName}'");
+            }
+        }
+
         /// <summary>
         /// Unregisters a hotkey for a specific channel
         /// </summary>
         public void UnregisterChannelHotkey(string channelName)
         {
-            if (_channelHotKeyIds.TryGetValue(channelName, out var hotKeyId))
+            // Unregister PTT hotkey
+            if (_channelHotKeyIds.TryGetValue(channelName, out var pttHotKeyId))
             {
-                _globalHotKeyManager.UnregisterHotKey(hotKeyId);
+                _globalHotKeyManager.UnregisterHotKey(pttHotKeyId);
                 _channelHotKeyIds.Remove(channelName);
-                _hotKeyIdToChannelName.Remove(hotKeyId);
+                _hotKeyIdToChannelName.Remove(pttHotKeyId);
+            }
+
+            // Unregister toggle hotkey
+            if (_channelToggleHotKeyIds.TryGetValue(channelName, out var toggleHotKeyId))
+            {
+                _globalHotKeyManager.UnregisterHotKey(toggleHotKeyId);
+                _channelToggleHotKeyIds.Remove(channelName);
+                _toggleHotKeyIdToChannelName.Remove(toggleHotKeyId);
             }
         }
 
@@ -143,10 +216,28 @@ public void UnregisterChannelHotkey(string channelName)
         /// </summary>
         public void UnregisterAllChannelHotkeys()
         {
+            // Unregister all PTT hotkeys
             var channelNames = new List<string>(_channelHotKeyIds.Keys);
             foreach (var channelName in channelNames)
             {
-                UnregisterChannelHotkey(channelName);
+                if (_channelHotKeyIds.TryGetValue(channelName, out var hotKeyId))
+                {
+                    _globalHotKeyManager.UnregisterHotKey(hotKeyId);
+                    _channelHotKeyIds.Remove(channelName);
+                    _hotKeyIdToChannelName.Remove(hotKeyId);
+                }
+            }
+
+            // Unregister all toggle hotkeys
+            var toggleChannelNames = new List<string>(_channelToggleHotKeyIds.Keys);
+            foreach (var channelName in toggleChannelNames)
+            {
+                if (_channelToggleHotKeyIds.TryGetValue(channelName, out var hotKeyId))
+                {
+                    _globalHotKeyManager.UnregisterHotKey(hotKeyId);
+                    _channelToggleHotKeyIds.Remove(channelName);
+                    _toggleHotKeyIdToChannelName.Remove(hotKeyId);
+                }
             }
         }
 
@@ -173,5 +264,17 @@ private void OnChannelHotKeyUp(string channelName)
                 _onChannelPttTriggered?.Invoke(channel, false);
             }
         }
+
+        /// <summary>
+        /// Called when a channel toggle hotkey is pressed
+        /// </summary>
+        private void OnChannelToggleHotKeyDown(string channelName)
+        {
+            var channel = _allChannels.FirstOrDefault(c => c.ChannelName == channelName);
+            if (channel != null)
+            {
+                _onChannelToggleTriggered?.Invoke(channel);
+            }
+        }
     }
 }
diff --git a/WhackerLinkConsoleV2/ChannelKeybindingManager.cs b/WhackerLinkConsoleV2/ChannelKeybindingManager.cs
index 0971293..cf56396 100644
--- a/WhackerLinkConsoleV2/ChannelKeybindingManager.cs
+++ b/WhackerLinkConsoleV2/ChannelKeybindingManager.cs
@@ -45,10 +45,16 @@ public class ChannelKeybindingManager
         public class ChannelKeybindingProfile
         {
             /// <summary>
-            /// Channel name -> keybinding string mapping (e.g., "MainChannel" -> "Ctrl+T")
+            /// Channel name -> PTT keybinding string mapping (e.g., "MainChannel" -> "Ctrl+T")
             /// </summary>
             public Dictionary<string, string> ChannelKeybindings { get; set; } = 
                 new Dictionary<string, string>();
+                
+            /// <summary>
+            /// Channel name -> toggle keybinding string mapping (e.g., "MainChannel" -> "Ctrl+G")
+            /// </summary>
+            public Dictionary<string, string> ChannelToggleKeybindings { get; set; } = 
+                new Dictionary<string, string>();
         }
 
         /// <summary>
@@ -143,6 +149,40 @@ public string GetChannelKeybinding(string codeplugIdentifier, string channelName
             return null;
         }
 
+        /// <summary>
+        /// Sets a toggle keybinding for a specific channel in a codeplug
+        /// </summary>
+        public void SetChannelToggleKeybinding(string codeplugIdentifier, string channelName, string keybinding)
+        {
+            var profile = GetOrCreateProfile(codeplugIdentifier);
+            
+            if (string.IsNullOrWhiteSpace(keybinding))
+            {
+                profile.ChannelToggleKeybindings.Remove(channelName);
+            }
+            else
+            {
+                profile.ChannelToggleKeybindings[channelName] = keybinding;
+            }
+
+            SaveKeybindings();
+            Console.WriteLine($"Set toggle keybinding for {channelName}: {keybinding}");
+        }
+
+        /// <summary>
+        /// Gets the toggle keybinding for a specific channel, returns null if not set
+        /// </summary>
+        public string GetChannelToggleKeybinding(string codeplugIdentifier, string channelName)
+        {
+            if (!_keybindingProfiles.TryGetValue(codeplugIdentifier, out var profile))
+                return null;
+
+            if (profile.ChannelToggleKeybindings.TryGetValue(channelName, out var keybinding))
+                return keybinding;
+
+            return null;
+        }
+
         /// <summary>
         /// Gets all channels with keybindings for a codeplug
         /// </summary>
@@ -154,6 +194,17 @@ public IEnumerable<string> GetChannelsWithKeybindings(string codeplugIdentifier)
             return new List<string>();
         }
 
+        /// <summary>
+        /// Gets all channels with toggle keybindings for a codeplug
+        /// </summary>
+        public IEnumerable<string> GetChannelsWithToggleKeybindings(string codeplugIdentifier)
+        {
+            if (_keybindingProfiles.TryGetValue(codeplugIdentifier, out var profile))
+                return profile.ChannelToggleKeybindings.Keys;
+
+            return new List<string>();
+        }
+
         /// <summary>
         /// Removes a keybinding for a specific channel
         /// </summary>
@@ -167,6 +218,19 @@ public void RemoveChannelKeybinding(string codeplugIdentifier, string channelNam
             }
         }
 
+        /// <summary>
+        /// Removes a toggle keybinding for a specific channel
+        /// </summary>
+        public void RemoveChannelToggleKeybinding(string codeplugIdentifier, string channelName)
+        {
+            var profile = GetOrCreateProfile(codeplugIdentifier);
+            if (profile.ChannelToggleKeybindings.Remove(channelName))
+            {
+                SaveKeybindings();
+                Console.WriteLine($"Removed toggle keybinding for {channelName}");
+            }
+        }
+
         /// <summary>
         /// Clears all keybindings for a codeplug profile
         /// </summary>
diff --git a/WhackerLinkConsoleV2/KeybindingConfigWindow.xaml b/WhackerLinkConsoleV2/KeybindingConfigWindow.xaml
index 8a896b6..2207ca8 100644
--- a/WhackerLinkConsoleV2/KeybindingConfigWindow.xaml
+++ b/WhackerLinkConsoleV2/KeybindingConfigWindow.xaml
@@ -1,7 +1,7 @@
 <Window x:Class="WhackerLinkConsoleV2.KeybindingConfigWindow"
         xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
-        Title="PTT Keybinding Configuration" Height="600" Width="800"
+        Title="Keybinding Configuration" Height="650" Width="800"
         WindowStartupLocation="CenterScreen">
     <Grid Margin="10">
         <Grid.RowDefinitions>
@@ -42,18 +42,50 @@
                     Grid.Column="2"/>
         </Grid>
 
-        <!-- Per-Channel Section -->
-        <TextBlock Text="Per-Channel PTT Keybindings" FontWeight="Bold" Grid.Row="2" Margin="0,0,0,5"/>
-        <ScrollViewer Grid.Row="2" Margin="0,25,0,0">
-            <StackPanel>
-                <TextBlock x:Name="CodeplugIdentifierText" 
-                           Text="No codeplug loaded" 
-                           FontSize="10" 
-                           Foreground="Gray" 
-                           Margin="0,0,0,10"/>
-                <StackPanel x:Name="ChannelKeybindingsPanel"/>
-            </StackPanel>
-        </ScrollViewer>
+        <!-- Tabbed Section for Per-Channel Keybindings -->
+        <TabControl Grid.Row="2" Margin="0,5,0,0">
+            <!-- PTT Keybindings Tab -->
+            <TabItem Header="PTT Keybindings">
+                <Grid Margin="10">
+                    <Grid.RowDefinitions>
+                        <RowDefinition Height="Auto"/>
+                        <RowDefinition Height="*"/>
+                    </Grid.RowDefinitions>
+                    
+                    <TextBlock x:Name="CodeplugIdentifierText" 
+                               Text="No codeplug loaded" 
+                               FontSize="10" 
+                               Foreground="Gray" 
+                               Margin="0,0,0,10"
+                               Grid.Row="0"/>
+                    
+                    <ScrollViewer Grid.Row="1">
+                        <StackPanel x:Name="ChannelKeybindingsPanel"/>
+                    </ScrollViewer>
+                </Grid>
+            </TabItem>
+            
+            <!-- Channel Toggle Keybindings Tab -->
+            <TabItem Header="Channel Toggle">
+                <Grid Margin="10">
+                    <Grid.RowDefinitions>
+                        <RowDefinition Height="Auto"/>
+                        <RowDefinition Height="*"/>
+                    </Grid.RowDefinitions>
+                    
+                    <TextBlock x:Name="CodeplugIdentifierTextToggle" 
+                               Text="No codeplug loaded" 
+                               FontSize="10" 
+                               Foreground="Gray" 
+                               Margin="0,0,0,10"
+                               Grid.Row="0"/>
+                    
+                    <ScrollViewer Grid.Row="1">
+                        <StackPanel x:Name="ChannelToggleKeybindingsPanel"/>
+                    </ScrollViewer>
+                </Grid>
+            </TabItem>
+        </TabControl>
 
         <!-- Footer Buttons -->
         <StackPanel Orientation="Horizontal" HorizontalAlignment="Right" Grid.Row="3" Margin="0,20,0,0">
diff --git a/WhackerLinkConsoleV2/KeybindingConfigWindow.xaml.cs b/WhackerLinkConsoleV2/KeybindingConfigWindow.xaml.cs
index 6670fdd..38487ac 100644
--- a/WhackerLinkConsoleV2/KeybindingConfigWindow.xaml.cs
+++ b/WhackerLinkConsoleV2/KeybindingConfigWindow.xaml.cs
@@ -39,6 +39,7 @@ public partial class KeybindingConfigWindow : Window
 
         private bool _recordingGlobalPtt = false;
         private Dictionary<string, TextBox> _channelKeybindingControls = new Dictionary<string, TextBox>();
+        private Dictionary<string, TextBox> _channelToggleKeybindingControls = new Dictionary<string, TextBox>();
 
         /// <summary>
         /// Gets whether keybindings were successfully applied and should take immediate effect
@@ -66,11 +67,18 @@ private void LoadSettings()
             // Load global keybinding
             GlobalPttKeybindDisplay.Text = _settingsManager.GlobalPttKeybind;
 
-            // Load codeplug identifier
+            // Load codeplug identifier for both tabs
             CodeplugIdentifierText.Text = _codeplugIdentifier;
+            CodeplugIdentifierTextToggle.Text = _codeplugIdentifier;
         }
 
         private void GenerateChannelControls()
+        {
+            GeneratePttChannelControls();
+            GenerateToggleChannelControls();
+        }
+
+        private void GeneratePttChannelControls()
         {
             ChannelKeybindingsPanel.Children.Clear();
             _channelKeybindingControls.Clear();
@@ -167,6 +175,103 @@ private void GenerateChannelControls()
             }
         }
 
+        private void GenerateToggleChannelControls()
+        {
+            ChannelToggleKeybindingsPanel.Children.Clear();
+            _channelToggleKeybindingControls.Clear();
+
+            if (_codeplug == null || _codeplug.Zones == null || _codeplug.Zones.Count == 0)
+            {
+                var noChannelsText = new TextBlock
+                {
+                    Text = "No channels available",
+                    Foreground = System.Windows.Media.Brushes.Gray,
+                    FontSize = 11,
+                    Margin = new Thickness(0, 10, 0, 0)
+                };
+                ChannelToggleKeybindingsPanel.Children.Add(noChannelsText);
+                return;
+            }
+
+            var allChannels = _codeplug.Zones.SelectMany(z => z.Channels).Distinct().OrderBy(c => c.Name).ToList();
+
+            if (allChannels.Count == 0)
+            {
+                var noChannelsText = new TextBlock
+                {
+                    Text = "No channels in codeplug",
+                    Foreground = System.Windows.Media.Brushes.Gray,
+                    FontSize = 11,
+                    Margin = new Thickness(0, 10, 0, 0)
+                };
+                ChannelToggleKeybindingsPanel.Children.Add(noChannelsText);
+                return;
+            }
+
+            foreach (var channel in allChannels)
+            {
+                var existingKeybind = _channelKeybindingManager.GetChannelToggleKeybinding(_codeplugIdentifier, channel.Name) ?? "";
+
+                var grid = new Grid
+                {
+                    Margin = new Thickness(0, 0, 0, 10)
+                };
+                grid.ColumnDefinitions.Add(new ColumnDefinition { Width = new GridLength(150) });
+                grid.ColumnDefinitions.Add(new ColumnDefinition { Width = new GridLength(1, GridUnitType.Star) });
+                grid.ColumnDefinitions.Add(new ColumnDefinition { Width = GridLength.Auto });
+                grid.ColumnDefinitions.Add(new ColumnDefinition { Width = GridLength.Auto });
+
+                // Channel name
+                var channelNameText = new TextBlock
+                {
+                    Text = channel.Name,
+                    VerticalAlignment = VerticalAlignment.Center,
+                    Margin = new Thickness(0, 0, 10, 0)
+                };
+                Grid.SetColumn(channelNameText, 0);
+                grid.Children.Add(channelNameText);
+
+                // Keybinding textbox
+                var keybindTextBox = new TextBox
+                {
+                    Text = existingKeybind,
+                    IsReadOnly = true,
+                    VerticalContentAlignment = VerticalAlignment.Center,
+                    Padding = new Thickness(5),
+                    Margin = new Thickness(0, 0, 10, 0)
+                };
+                Grid.SetColumn(keybindTextBox, 1);
+                grid.Children.Add(keybindTextBox);
+
+                _channelToggleKeybindingControls[channel.Name] = keybindTextBox;
+
+                // Record button
+                var recordButton = new Button
+                {
+                    Content = "Record",
+                    Width = 80,
+                    Tag = channel.Name,
+                    Margin = new Thickness(0, 0, 10, 0)
+                };
+                recordButton.Click += (s, e) => RecordChannelToggleKeybind_Click(channel.Name);
+                Grid.SetColumn(recordButton, 2);
+                grid.Children.Add(recordButton);
+
+                // Clear button
+                var clearButton = new Button
+                {
+                    Content = "Clear",
+                    Width = 80,
+                    Tag = channel.Name
+                };
+                clearButton.Click += (s, e) => ClearChannelToggleKeybind_Click(channel.Name);
+                Grid.SetColumn(clearButton, 3);
+                grid.Children.Add(clearButton);
+
+                ChannelToggleKeybindingsPanel.Children.Add(grid);
+            }
+        }
+
         private void RecordGlobalPtt_Click(object sender, RoutedEventArgs e)
         {
             _recordingGlobalPtt = true;
@@ -180,7 +285,18 @@ private void RecordChannelKeybind_Click(string channelName)
             if (!_channelKeybindingControls.TryGetValue(channelName, out var textBox))
                 return;
 
-            var recordingTag = $"recording_{channelName}";
+            var recordingTag = $"recording_ptt_{channelName}";
+            Tag = recordingTag;
+            textBox.Text = "Press keys...";
+            Focus();
+        }
+
+        private void RecordChannelToggleKeybind_Click(string channelName)
+        {
+            if (!_channelToggleKeybindingControls.TryGetValue(channelName, out var textBox))
+                return;
+
+            var recordingTag = $"recording_toggle_{channelName}";
             Tag = recordingTag;
             textBox.Text = "Press keys...";
             Focus();
@@ -192,11 +308,16 @@ private void ClearChannelKeybind_Click(string channelName)
                 return;
 
             textBox.Text = "";
-            // Reset any recording state for this channel
-            if (Tag is string tag && tag == $"recording_{channelName}")
-            {
-                Tag = null;
-            }
+            _channelKeybindingManager.SetChannelKeybinding(_codeplugIdentifier, channelName, "");
+        }
+
+        private void ClearChannelToggleKeybind_Click(string channelName)
+        {
+            if (!_channelToggleKeybindingControls.TryGetValue(channelName, out var textBox))
+                return;
+
+            textBox.Text = "";
+            _channelKeybindingManager.SetChannelToggleKeybinding(_codeplugIdentifier, channelName, "");
         }
 
         private void ClearGlobalPtt_Click(object sender, RoutedEventArgs e)
@@ -245,13 +366,26 @@ protected override void OnPreviewKeyDown(KeyEventArgs e)
             // Handle channel-specific keybind recording
             if (Tag is string tag && tag.StartsWith("recording_"))
             {
-                var channelName = tag.Substring("recording_".Length);
-                if (_channelKeybindingControls.TryGetValue(channelName, out var textBox))
+                var keybinding = KeybindingParser.KeybindingToString(modifiers, key);
+                
+                if (tag.StartsWith("recording_ptt_"))
                 {
-                    var keybinding = KeybindingParser.KeybindingToString(modifiers, key);
-                    textBox.Text = keybinding;
-                    Tag = null;
+                    var channelName = tag.Substring("recording_ptt_".Length);
+                    if (_channelKeybindingControls.TryGetValue(channelName, out var textBox))
+                    {
+                        textBox.Text = keybinding;
+                    }
+                }
+                else if (tag.StartsWith("recording_toggle_"))
+                {
+                    var channelName = tag.Substring("recording_toggle_".Length);
+                    if (_channelToggleKeybindingControls.TryGetValue(channelName, out var textBox))
+                    {
+                        textBox.Text = keybinding;
+                    }
                 }
+                
+                Tag = null;
                 e.Handled = true;
                 return;
             }
@@ -289,13 +423,35 @@ private void Apply_Click(object sender, RoutedEventArgs e)
                 {
                     if (!KeybindingParser.TryParseKeybinding(keybinding, out _, out _))
                     {
-                        MessageBox.Show($"Invalid keybinding for channel '{channelName}': {keybinding}", "Validation Error", MessageBoxButton.OK, MessageBoxImage.Warning);
+                        MessageBox.Show($"Invalid PTT keybinding for channel '{channelName}': {keybinding}", "Validation Error", MessageBoxButton.OK, MessageBoxImage.Warning);
                         return;
                     }
                     _channelKeybindingManager.SetChannelKeybinding(_codeplugIdentifier, channelName, keybinding);
                 }
             }
 
+            // Validate and save per-channel toggle keybindings
+            foreach (var kvp in _channelToggleKeybindingControls)
+            {
+                var channelName = kvp.Key;
+                var textBox = kvp.Value;
+                var keybinding = textBox.Text;
+
+                if (string.IsNullOrWhiteSpace(keybinding))
+                {
+                    _channelKeybindingManager.RemoveChannelToggleKeybinding(_codeplugIdentifier, channelName);
+                }
+                else
+                {
+                    if (!KeybindingParser.TryParseKeybinding(keybinding, out _, out _))
+                    {
+                        MessageBox.Show($"Invalid toggle keybinding for channel '{channelName}': {keybinding}", "Validation Error", MessageBoxButton.OK, MessageBoxImage.Warning);
+                        return;
+                    }
+                    _channelKeybindingManager.SetChannelToggleKeybinding(_codeplugIdentifier, channelName, keybinding);
+                }
+            }
+
             KeybindingsApplied = true;
 
             MessageBox.Show("Keybindings saved and applied successfully!", "Success", MessageBoxButton.OK, MessageBoxImage.Information);
diff --git a/WhackerLinkConsoleV2/MainWindow.xaml b/WhackerLinkConsoleV2/MainWindow.xaml
index fbb0dcc..fb490ac 100644
--- a/WhackerLinkConsoleV2/MainWindow.xaml
+++ b/WhackerLinkConsoleV2/MainWindow.xaml
@@ -31,7 +31,7 @@
             </MenuItem>
             <MenuItem Header="Edit">
                 <MenuItem Header="Audio Settings" Click="AudioSettings_Click" />
-                <MenuItem Header="Configure PTT Keybindings" Click="ConfigurePttKeybindings_Click"/>
+                <MenuItem Header="Configure Keybindings" Click="ConfigurePttKeybindings_Click"/>
                 <MenuItem Header="Enable Edit Mode" Click="ToggleEditMode_Click"/>
                 <MenuItem Header="Select Widgets to Display" Click="SelectWidgets_Click"/>
                 <MenuItem Header="Reset Settings" Click="ResetSettings_Click"/>
diff --git a/WhackerLinkConsoleV2/MainWindow.xaml.cs b/WhackerLinkConsoleV2/MainWindow.xaml.cs
index 96c4fca..0e2550b 100644
--- a/WhackerLinkConsoleV2/MainWindow.xaml.cs
+++ b/WhackerLinkConsoleV2/MainWindow.xaml.cs
@@ -714,7 +714,8 @@ private void InitializeChannelHotkeys()
                     _channelHotKeyManager = new ChannelHotKeyManager(
                         _globalHotKeyManager,
                         _channelKeybindingManager,
-                        OnChannelHotKeyTriggered
+                        OnChannelHotKeyTriggered,
+                        OnChannelToggleTriggered
                     );
                 }
 
@@ -808,6 +809,21 @@ private void OnChannelHotKeyTriggered(ChannelBox channel, bool isPressed)
             });
         }
 
+        private void OnChannelToggleTriggered(ChannelBox channel)
+        {
+            Dispatcher.Invoke(() =>
+            {
+                if (channel != null)
+                {
+                    // Toggle the channel's selection state (like clicking on it)
+                    channel.ToggleSelection();
+                    
+                    // Optionally log the toggle action
+                    Console.WriteLine($"Channel '{channel.ChannelName}' toggled to {(channel.IsSelected ? "selected" : "unselected")}");
+                }
+            });
+        }
+
         private async void ActivateGlobalPtt()
         {
             foreach (ChannelBox channel in _selectedChannelsManager.GetSelectedChannels())

From 8afe4d6dc25da6277c0ba921b4a515b4bb8e0e99 Mon Sep 17 00:00:00 2001
From: Firav <firavv@gmail.com>
Date: Mon, 15 Dec 2025 13:46:53 -0500
Subject: [PATCH 11/13] Allow for combo keybinds to be recorded and set, fixed
 bug with removing global PTT value. Fixes #5.

---
 .../KeybindingConfigWindow.xaml.cs            | 159 +++++++++++++++---
 WhackerLinkConsoleV2/KeybindingParser.cs      |  17 +-
 2 files changed, 148 insertions(+), 28 deletions(-)

diff --git a/WhackerLinkConsoleV2/KeybindingConfigWindow.xaml.cs b/WhackerLinkConsoleV2/KeybindingConfigWindow.xaml.cs
index 38487ac..4512b2e 100644
--- a/WhackerLinkConsoleV2/KeybindingConfigWindow.xaml.cs
+++ b/WhackerLinkConsoleV2/KeybindingConfigWindow.xaml.cs
@@ -40,6 +40,13 @@ public partial class KeybindingConfigWindow : Window
         private bool _recordingGlobalPtt = false;
         private Dictionary<string, TextBox> _channelKeybindingControls = new Dictionary<string, TextBox>();
         private Dictionary<string, TextBox> _channelToggleKeybindingControls = new Dictionary<string, TextBox>();
+        
+        // Key recording state tracking
+        private bool _isRecording = false;
+        private ModifierKeys _recordedModifiers = ModifierKeys.None;
+        private Key _recordedKey = Key.None;
+        private string _pendingKeybinding = "";
+        private readonly HashSet<Key> _pressedKeys = new HashSet<Key>();
 
         /// <summary>
         /// Gets whether keybindings were successfully applied and should take immediate effect
@@ -274,6 +281,7 @@ private void GenerateToggleChannelControls()
 
         private void RecordGlobalPtt_Click(object sender, RoutedEventArgs e)
         {
+            StartRecording();
             _recordingGlobalPtt = true;
             RecordGlobalPttButton.Content = "Press keys...";
             RecordGlobalPttButton.IsEnabled = false;
@@ -285,6 +293,7 @@ private void RecordChannelKeybind_Click(string channelName)
             if (!_channelKeybindingControls.TryGetValue(channelName, out var textBox))
                 return;
 
+            StartRecording();
             var recordingTag = $"recording_ptt_{channelName}";
             Tag = recordingTag;
             textBox.Text = "Press keys...";
@@ -296,6 +305,7 @@ private void RecordChannelToggleKeybind_Click(string channelName)
             if (!_channelToggleKeybindingControls.TryGetValue(channelName, out var textBox))
                 return;
 
+            StartRecording();
             var recordingTag = $"recording_toggle_{channelName}";
             Tag = recordingTag;
             textBox.Text = "Press keys...";
@@ -326,19 +336,46 @@ private void ClearGlobalPtt_Click(object sender, RoutedEventArgs e)
             // Reset global PTT recording state if active
             if (_recordingGlobalPtt)
             {
+                StopRecording();
                 _recordingGlobalPtt = false;
                 RecordGlobalPttButton.Content = "Record";
                 RecordGlobalPttButton.IsEnabled = true;
             }
         }
 
+        private void StartRecording()
+        {
+            _isRecording = true;
+            _recordedModifiers = ModifierKeys.None;
+            _recordedKey = Key.None;
+            _pendingKeybinding = "";
+            _pressedKeys.Clear();
+        }
+        
+        private void StopRecording()
+        {
+            _isRecording = false;
+            _recordedModifiers = ModifierKeys.None;
+            _recordedKey = Key.None;
+            _pendingKeybinding = "";
+            _pressedKeys.Clear();
+        }
+
         protected override void OnPreviewKeyDown(KeyEventArgs e)
         {
-            // Get current modifiers
-            var modifiers = Keyboard.Modifiers;
-            var key = e.Key;
+            if (!_isRecording)
+            {
+                base.OnPreviewKeyDown(e);
+                return;
+            }
 
-            // Don't record if only a modifier key is pressed (wait for the actual key)
+            var key = e.Key;
+            var modifiers = Keyboard.Modifiers;
+            
+            // Track all pressed keys
+            _pressedKeys.Add(key);
+            
+            // If this is a modifier key, just track it
             if (key == Key.LeftCtrl || key == Key.RightCtrl ||
                 key == Key.LeftShift || key == Key.RightShift ||
                 key == Key.LeftAlt || key == Key.RightAlt ||
@@ -346,34 +383,104 @@ protected override void OnPreviewKeyDown(KeyEventArgs e)
                 key == Key.System)
             {
                 e.Handled = true;
+                UpdateRecordingDisplay(modifiers, Key.None);
                 return;
             }
-
-            // Handle global PTT recording
+            
+            // This is a non-modifier key - capture the combination
+            _recordedModifiers = modifiers;
+            _recordedKey = key;
+            _pendingKeybinding = KeybindingParser.KeybindingToString(modifiers, key);
+            
+            UpdateRecordingDisplay(modifiers, key);
+            e.Handled = true;
+        }
+        
+        protected override void OnPreviewKeyUp(KeyEventArgs e)
+        {
+            if (!_isRecording)
+            {
+                base.OnPreviewKeyUp(e);
+                return;
+            }
+            
+            var key = e.Key;
+            _pressedKeys.Remove(key);
+            
+            // If all keys have been released and we have a pending keybinding, finalize it
+            if (_pressedKeys.Count == 0 && !string.IsNullOrEmpty(_pendingKeybinding))
+            {
+                FinalizeRecording();
+            }
+            
+            e.Handled = true;
+        }
+        
+        private void UpdateRecordingDisplay(ModifierKeys modifiers, Key key)
+        {
+            string displayText;
+            if (key == Key.None)
+            {
+                // Show just the modifiers being held
+                displayText = KeybindingParser.ModifiersToString(modifiers);
+                if (string.IsNullOrEmpty(displayText))
+                {
+                    displayText = "Press keys...";
+                }
+                else
+                {
+                    displayText += "+...";
+                }
+            }
+            else
+            {
+                displayText = KeybindingParser.KeybindingToString(modifiers, key);
+            }
+            
+            // Update the appropriate display
             if (_recordingGlobalPtt)
             {
-                var keybinding = KeybindingParser.KeybindingToString(modifiers, key);
-                GlobalPttKeybindDisplay.Text = keybinding;
-                
+                GlobalPttKeybindDisplay.Text = displayText;
+            }
+            else if (Tag is string tag && tag.StartsWith("recording_"))
+            {
+                if (tag.StartsWith("recording_ptt_"))
+                {
+                    var channelName = tag.Substring("recording_ptt_".Length);
+                    if (_channelKeybindingControls.TryGetValue(channelName, out var textBox))
+                    {
+                        textBox.Text = displayText;
+                    }
+                }
+                else if (tag.StartsWith("recording_toggle_"))
+                {
+                    var channelName = tag.Substring("recording_toggle_".Length);
+                    if (_channelToggleKeybindingControls.TryGetValue(channelName, out var textBox))
+                    {
+                        textBox.Text = displayText;
+                    }
+                }
+            }
+        }
+        
+        private void FinalizeRecording()
+        {
+            // Complete the recording with the captured keybinding
+            if (_recordingGlobalPtt)
+            {
+                GlobalPttKeybindDisplay.Text = _pendingKeybinding;
                 _recordingGlobalPtt = false;
                 RecordGlobalPttButton.Content = "Record";
                 RecordGlobalPttButton.IsEnabled = true;
-                
-                e.Handled = true;
-                return;
             }
-
-            // Handle channel-specific keybind recording
-            if (Tag is string tag && tag.StartsWith("recording_"))
+            else if (Tag is string tag && tag.StartsWith("recording_"))
             {
-                var keybinding = KeybindingParser.KeybindingToString(modifiers, key);
-                
                 if (tag.StartsWith("recording_ptt_"))
                 {
                     var channelName = tag.Substring("recording_ptt_".Length);
                     if (_channelKeybindingControls.TryGetValue(channelName, out var textBox))
                     {
-                        textBox.Text = keybinding;
+                        textBox.Text = _pendingKeybinding;
                     }
                 }
                 else if (tag.StartsWith("recording_toggle_"))
@@ -381,22 +488,24 @@ protected override void OnPreviewKeyDown(KeyEventArgs e)
                     var channelName = tag.Substring("recording_toggle_".Length);
                     if (_channelToggleKeybindingControls.TryGetValue(channelName, out var textBox))
                     {
-                        textBox.Text = keybinding;
+                        textBox.Text = _pendingKeybinding;
                     }
                 }
-                
                 Tag = null;
-                e.Handled = true;
-                return;
             }
-
-            base.OnPreviewKeyDown(e);
+            
+            StopRecording();
         }
 
         private void Apply_Click(object sender, RoutedEventArgs e)
         {
             // Validate and save global keybinding
-            if (!string.IsNullOrWhiteSpace(GlobalPttKeybindDisplay.Text))
+            if (string.IsNullOrWhiteSpace(GlobalPttKeybindDisplay.Text))
+            {
+                // Clear the global PTT keybinding
+                _settingsManager.GlobalPttKeybind = "";
+            }
+            else
             {
                 if (!KeybindingParser.TryParseKeybinding(GlobalPttKeybindDisplay.Text, out _, out _))
                 {
diff --git a/WhackerLinkConsoleV2/KeybindingParser.cs b/WhackerLinkConsoleV2/KeybindingParser.cs
index a7a3074..71b6525 100644
--- a/WhackerLinkConsoleV2/KeybindingParser.cs
+++ b/WhackerLinkConsoleV2/KeybindingParser.cs
@@ -127,6 +127,19 @@ public static bool TryParseKeybinding(string keybindingString, out ModifierKeys
         /// Converts ModifierKeys and Key back to a keybinding string
         /// </summary>
         public static string KeybindingToString(ModifierKeys modifiers, Key key)
+        {
+            var result = ModifiersToString(modifiers);
+            if (!string.IsNullOrEmpty(result))
+                result += "+";
+            result += key.ToString();
+
+            return result;
+        }
+
+        /// <summary>
+        /// Converts ModifierKeys to a string representation (without the final key)
+        /// </summary>
+        public static string ModifiersToString(ModifierKeys modifiers)
         {
             var result = "";
 
@@ -139,9 +152,7 @@ public static string KeybindingToString(ModifierKeys modifiers, Key key)
             if ((modifiers & ModifierKeys.Windows) == ModifierKeys.Windows)
                 result += "Win+";
 
-            result += key.ToString();
-
-            return result;
+            return result.TrimEnd('+');
         }
     }
 }

From d07f3734f76097003c2b9e7bdcee1e292c11209d Mon Sep 17 00:00:00 2001
From: Firav <firavv@gmail.com>
Date: Thu, 5 Feb 2026 12:35:26 -0500
Subject: [PATCH 12/13] Complete overhaul to the keybind hook system. - Fixes
 issue with keys being locked out system wide. - Closes #6. - Adds user option
 to toggle keybind focus

---
 WhackerLinkConsoleV2/GlobalHotKeyManager.cs   | 394 +++++++++---------
 .../KeybindingConfigWindow.xaml               |  21 +-
 .../KeybindingConfigWindow.xaml.cs            |   9 +
 WhackerLinkConsoleV2/MainWindow.xaml.cs       |   3 +
 WhackerLinkConsoleV2/SettingsManager.cs       |   4 +
 5 files changed, 223 insertions(+), 208 deletions(-)

diff --git a/WhackerLinkConsoleV2/GlobalHotKeyManager.cs b/WhackerLinkConsoleV2/GlobalHotKeyManager.cs
index 9fef052..b72f587 100644
--- a/WhackerLinkConsoleV2/GlobalHotKeyManager.cs
+++ b/WhackerLinkConsoleV2/GlobalHotKeyManager.cs
@@ -25,6 +25,7 @@
 using System.Windows.Interop;
 using System.Windows;
 using System.Windows.Input;
+using System.Diagnostics;
 
 namespace WhackerLinkConsoleV2
 {
@@ -39,48 +40,69 @@ public class HotKeyEventArgs : EventArgs
     }
 
     /// <summary>
-    /// Manages global system hotkeys using Windows API
+    /// Manages global system hotkeys using low-level keyboard hooks
     /// </summary>
     public class GlobalHotKeyManager : IDisposable
     {
-        // Windows API P/Invoke declarations
-        [DllImport("user32.dll")]
-        private static extern bool RegisterHotKey(IntPtr hWnd, int id, uint fsModifiers, uint vk);
+        // Windows API P/Invoke declarations for keyboard hooks
+        [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
+        private static extern IntPtr SetWindowsHookEx(int idHook, LowLevelKeyboardProc lpfn, IntPtr hMod, uint dwThreadId);
 
-        [DllImport("user32.dll")]
-        private static extern bool UnregisterHotKey(IntPtr hWnd, int id);
+        [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
+        [return: MarshalAs(UnmanagedType.Bool)]
+        private static extern bool UnhookWindowsHookEx(IntPtr hhk);
 
-        [DllImport("user32.dll")]
-        private static extern uint MapVirtualKey(uint uCode, uint uMapType);
+        [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
+        private static extern IntPtr CallNextHookEx(IntPtr hhk, int nCode, IntPtr wParam, IntPtr lParam);
 
-        [DllImport("kernel32.dll")]
-        private static extern uint GetLastError();
+        [DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)]
+        private static extern IntPtr GetModuleHandle(string lpModuleName);
 
         [DllImport("user32.dll")]
         private static extern short GetAsyncKeyState(int vKey);
 
-        // Modifier key constants
-        private const uint MOD_NONE = 0x0000;
-        private const uint MOD_ALT = 0x0001;
-        private const uint MOD_CONTROL = 0x0002;
-        private const uint MOD_SHIFT = 0x0004;
-        private const uint MOD_WIN = 0x0008;
+        [DllImport("user32.dll")]
+        private static extern IntPtr GetForegroundWindow();
 
-        // Message constants
-        private const int WM_HOTKEY = 0x0312;
+        // Hook constants
+        private const int WH_KEYBOARD_LL = 13;
+        private const int WM_KEYDOWN = 0x0100;
+        private const int WM_KEYUP = 0x0101;
+        private const int WM_SYSKEYDOWN = 0x0104;
+        private const int WM_SYSKEYUP = 0x0105;
 
         // Virtual key codes for modifier keys
         private const int VK_CONTROL = 0x11;
         private const int VK_SHIFT = 0x10;
         private const int VK_MENU = 0x12; // Alt key
 
+        // Delegate for low-level keyboard hook
+        private delegate IntPtr LowLevelKeyboardProc(int nCode, IntPtr wParam, IntPtr lParam);
+
+        [StructLayout(LayoutKind.Sequential)]
+        private struct KBDLLHOOKSTRUCT
+        {
+            public uint vkCode;
+            public uint scanCode;
+            public uint flags;
+            public uint time;
+            public IntPtr dwExtraInfo;
+        }
+
         private Window _window;
         private IntPtr _windowHandle;
-        private HwndSource _hwndSource;
+        private IntPtr _hookId = IntPtr.Zero;
+        private LowLevelKeyboardProc _hookCallback;
         private Dictionary<int, HotKeyInfo> _registeredHotKeys = new Dictionary<int, HotKeyInfo>();
         private Dictionary<int, bool> _hotKeyStates = new Dictionary<int, bool>(); // Track if hotkey is currently pressed
+        private Dictionary<int, int> _vkCodeToHotKeyId = new Dictionary<int, int>(); // Map VK code to the currently active hotkey ID for that key
         private int _nextHotKeyId = 1;
-        private System.Timers.Timer _keyStateTimer;
+        private HashSet<int> _currentlyPressedVKs = new HashSet<int>(); // Track currently pressed virtual keys
+        
+        /// <summary>
+        /// Gets or sets whether hotkeys should work when the application is not focused
+        /// </summary>
+        public bool WorkWhenUnfocused { get; set; } = true;
 
         public event EventHandler<HotKeyEventArgs> HotKeyPressed;
         public event EventHandler<HotKeyEventArgs> HotKeyReleased;
@@ -110,17 +132,20 @@ public void Initialize(Window window)
                 throw new InvalidOperationException("Window handle is invalid. Ensure the window is fully initialized.");
             }
 
-            _hwndSource = HwndSource.FromHwnd(_windowHandle);
-            if (_hwndSource != null)
+            // Set up the low-level keyboard hook
+            _hookCallback = HookCallback;
+            using (Process curProcess = Process.GetCurrentProcess())
+            using (ProcessModule curModule = curProcess.MainModule)
             {
-                _hwndSource.AddHook(HwndHook);
+                _hookId = SetWindowsHookEx(WH_KEYBOARD_LL, _hookCallback, GetModuleHandle(curModule.ModuleName), 0);
             }
 
-            // Start a timer to poll key states for detecting key releases
-            _keyStateTimer = new System.Timers.Timer(50); // Poll every 50ms
-            _keyStateTimer.Elapsed += CheckKeyStates;
-            _keyStateTimer.AutoReset = true;
-            _keyStateTimer.Start();
+            if (_hookId == IntPtr.Zero)
+            {
+                throw new InvalidOperationException("Failed to install keyboard hook.");
+            }
+
+            Console.WriteLine("Low-level keyboard hook installed successfully.");
         }
 
         /// <summary>
@@ -129,21 +154,13 @@ public void Initialize(Window window)
         /// <returns>Returns the hotkey ID if successful, -1 if failed</returns>
         public int RegisterHotKey(ModifierKeys modifier, Key key, Action onKeyDown = null, Action onKeyUp = null)
         {
-            if (_windowHandle == IntPtr.Zero)
+            if (_hookId == IntPtr.Zero)
             {
                 Console.WriteLine($"ERROR: GlobalHotKeyManager not initialized. Call Initialize() first.");
                 return -1;
             }
 
-            // Single-key hotkeys without modifiers are not recommended and may be rejected by Windows
-            if (modifier == ModifierKeys.None)
-            {
-                Console.WriteLine($"WARNING: Single-key hotkey without modifiers ({key}) may not work reliably or may be rejected by Windows.");
-                Console.WriteLine($"         It's recommended to use at least one modifier key (e.g., Ctrl+{key}).");
-            }
-
             int hotKeyId = _nextHotKeyId++;
-            uint modifierFlags = ConvertModifierKeys(modifier);
             uint vkCode = (uint)KeyInterop.VirtualKeyFromKey(key);
 
             if (vkCode == 0)
@@ -152,35 +169,21 @@ public int RegisterHotKey(ModifierKeys modifier, Key key, Action onKeyDown = nul
                 return -1;
             }
 
-            if (RegisterHotKey(_windowHandle, hotKeyId, modifierFlags, vkCode))
+            var hotKeyInfo = new HotKeyInfo
             {
-                var hotKeyInfo = new HotKeyInfo
-                {
-                    Id = hotKeyId,
-                    Key = key,
-                    Modifiers = modifier,
-                    OnKeyDown = onKeyDown,
-                    OnKeyUp = onKeyUp
-                };
-
-                _registeredHotKeys[hotKeyId] = hotKeyInfo;
-                
-                return hotKeyId;
-            }
-            else
-            {
-                uint error = GetLastError();
-                string modifierStr = modifier == ModifierKeys.None ? "(no modifiers)" : modifier.ToString();
-                Console.WriteLine($"ERROR: Failed to register hotkey {modifierStr}+{key}. Error code: {error}");
-                
-                // Common error codes
-                if (error == 1409) // ERROR_HOTKEY_ALREADY_REGISTERED
-                {
-                    Console.WriteLine($"       This hotkey is already registered by another application.");
-                }
-                
-                return -1;
-            }
+                Id = hotKeyId,
+                Key = key,
+                Modifiers = modifier,
+                OnKeyDown = onKeyDown,
+                OnKeyUp = onKeyUp
+            };
+
+            _registeredHotKeys[hotKeyId] = hotKeyInfo;
+            
+            string modifierStr = modifier == ModifierKeys.None ? "(no modifiers)" : modifier.ToString();
+            Console.WriteLine($"Registered hotkey: {modifierStr}+{key} (ID: {hotKeyId})");
+            
+            return hotKeyId;
         }
 
         /// <summary>
@@ -194,17 +197,10 @@ public bool UnregisterHotKey(int hotKeyId)
                 return false;
             }
 
-            if (UnregisterHotKey(_windowHandle, hotKeyId))
-            {
-                _registeredHotKeys.Remove(hotKeyId);
-                return true;
-            }
-            else
-            {
-                uint error = GetLastError();
-                Console.WriteLine($"ERROR: Failed to unregister hotkey ID {hotKeyId}. Error code: {error}");
-                return false;
-            }
+            _registeredHotKeys.Remove(hotKeyId);
+            _hotKeyStates.Remove(hotKeyId);
+            Console.WriteLine($"Unregistered hotkey ID {hotKeyId}");
+            return true;
         }
 
         /// <summary>
@@ -246,146 +242,137 @@ public IEnumerable<int> GetRegisteredHotKeyIds()
         }
 
         /// <summary>
-        /// Converts WPF ModifierKeys to Windows API modifier flags
-        /// </summary>
-        private uint ConvertModifierKeys(ModifierKeys modifiers)
-        {
-            uint result = MOD_NONE;
-
-            if ((modifiers & ModifierKeys.Alt) == ModifierKeys.Alt)
-                result |= MOD_ALT;
-            if ((modifiers & ModifierKeys.Control) == ModifierKeys.Control)
-                result |= MOD_CONTROL;
-            if ((modifiers & ModifierKeys.Shift) == ModifierKeys.Shift)
-                result |= MOD_SHIFT;
-            if ((modifiers & ModifierKeys.Windows) == ModifierKeys.Windows)
-                result |= MOD_WIN;
-
-            return result;
-        }
-
-        /// <summary>
-        /// Window message hook for processing hotkey messages
+        /// Low-level keyboard hook callback
         /// </summary>
-        private IntPtr HwndHook(IntPtr hwnd, int msg, IntPtr wParam, IntPtr lParam, ref bool handled)
+        private IntPtr HookCallback(int nCode, IntPtr wParam, IntPtr lParam)
         {
-            if (msg == WM_HOTKEY)
+            if (nCode >= 0)
             {
-                int hotKeyId = wParam.ToInt32();
+                bool isKeyDown = (wParam == (IntPtr)WM_KEYDOWN || wParam == (IntPtr)WM_SYSKEYDOWN);
+                bool isKeyUp = (wParam == (IntPtr)WM_KEYUP || wParam == (IntPtr)WM_SYSKEYUP);
 
-                if (_registeredHotKeys.TryGetValue(hotKeyId, out var hotKeyInfo))
+                if (isKeyDown || isKeyUp)
                 {
-                    // Check if this hotkey is already pressed (to prevent repeated triggers)
-                    bool wasAlreadyPressed = _hotKeyStates.TryGetValue(hotKeyId, out bool isPressed) && isPressed;
+                    KBDLLHOOKSTRUCT hookStruct = (KBDLLHOOKSTRUCT)Marshal.PtrToStructure(lParam, typeof(KBDLLHOOKSTRUCT));
+                    int vkCode = (int)hookStruct.vkCode;
 
-                    if (!wasAlreadyPressed)
+                    // Track currently pressed keys
+                    if (isKeyDown)
                     {
-                        // Only trigger on first press, not repeated WM_HOTKEY messages
-                        var args = new HotKeyEventArgs
-                        {
-                            HotKeyId = hotKeyId,
-                            Key = hotKeyInfo.Key,
-                            Modifiers = hotKeyInfo.Modifiers
-                        };
-
-                        // Fire the pressed event
-                        HotKeyPressed?.Invoke(this, args);
-
-                        // Call the on-key-down callback if registered
-                        hotKeyInfo.OnKeyDown?.Invoke();
-
-                        // Mark this hotkey as pressed
-                        _hotKeyStates[hotKeyId] = true;
+                        _currentlyPressedVKs.Add(vkCode);
                     }
-
-                    handled = true;
-                }
-            }
-
-            return IntPtr.Zero;
-        }
-
-        /// <summary>
-        /// Checks if keys are still pressed (polling for key release detection)
-        /// </summary>
-        private void CheckKeyStates(object sender, System.Timers.ElapsedEventArgs e)
-        {
-            var hotKeysToRelease = new List<int>();
-
-            foreach (var kvp in _registeredHotKeys)
-            {
-                int hotKeyId = kvp.Key;
-                var hotKeyInfo = kvp.Value;
-
-                // Check if this hotkey is currently marked as pressed
-                if (_hotKeyStates.TryGetValue(hotKeyId, out bool isPressed) && isPressed)
-                {
-                    // Check if the key combination is still held
-                    if (!IsKeyCombinationPressed(hotKeyInfo.Modifiers, hotKeyInfo.Key))
+                    else if (isKeyUp)
                     {
-                        hotKeysToRelease.Add(hotKeyId);
+                        _currentlyPressedVKs.Remove(vkCode);
                     }
-                }
-            }
 
-            // Release keys that are no longer pressed
-            foreach (var hotKeyId in hotKeysToRelease)
-            {
-                _hotKeyStates[hotKeyId] = false;
+                    // Check if we should process hotkeys (based on focus setting)
+                    if (!WorkWhenUnfocused)
+                    {
+                        IntPtr foregroundWindow = GetForegroundWindow();
+                        if (foregroundWindow != _windowHandle)
+                        {
+                            // App is not focused and WorkWhenUnfocused is false, so ignore
+                            return CallNextHookEx(_hookId, nCode, wParam, lParam);
+                        }
+                    }
 
-                if (_registeredHotKeys.TryGetValue(hotKeyId, out var hotKeyInfo))
-                {
-                    // Call the on-key-up callback if registered
-                    _window?.Dispatcher.Invoke(() =>
+                    if (isKeyDown)
                     {
-                        hotKeyInfo.OnKeyUp?.Invoke();
-                    });
+                        // Get current modifier state
+                        ModifierKeys currentModifiers = GetCurrentModifiers();
 
-                    // Fire the released event
-                    _window?.Dispatcher.Invoke(() =>
+                        // Check all registered hotkeys for a match
+                        foreach (var kvp in _registeredHotKeys)
+                        {
+                            var hotKeyInfo = kvp.Value;
+                            int hotKeyId = kvp.Key;
+
+                            // Check if this hotkey matches the current key + modifiers
+                            int hotKeyVK = KeyInterop.VirtualKeyFromKey(hotKeyInfo.Key);
+                            
+                            if (hotKeyVK == vkCode && currentModifiers == hotKeyInfo.Modifiers)
+                            {
+                                // Check if already pressed to prevent repeats
+                                bool wasAlreadyPressed = _hotKeyStates.TryGetValue(hotKeyId, out bool isPressed) && isPressed;
+                                
+                                if (!wasAlreadyPressed)
+                                {
+                                    _hotKeyStates[hotKeyId] = true;
+                                    _vkCodeToHotKeyId[vkCode] = hotKeyId; // Track which hotkey this VK is associated with
+
+                                    // Dispatch to UI thread
+                                    _window?.Dispatcher.BeginInvoke(new Action(() =>
+                                    {
+                                        var args = new HotKeyEventArgs
+                                        {
+                                            HotKeyId = hotKeyId,
+                                            Key = hotKeyInfo.Key,
+                                            Modifiers = hotKeyInfo.Modifiers
+                                        };
+
+                                        HotKeyPressed?.Invoke(this, args);
+                                        hotKeyInfo.OnKeyDown?.Invoke();
+                                    }));
+                                }
+                                break; // Found a match, no need to check other hotkeys
+                            }
+                        }
+                    }
+                    else if (isKeyUp)
                     {
-                        var args = new HotKeyEventArgs
+                        // Check if this VK code was associated with a hotkey press
+                        if (_vkCodeToHotKeyId.TryGetValue(vkCode, out int hotKeyId))
                         {
-                            HotKeyId = hotKeyId,
-                            Key = hotKeyInfo.Key,
-                            Modifiers = hotKeyInfo.Modifiers
-                        };
-                        HotKeyReleased?.Invoke(this, args);
-                    });
+                            // Mark as released
+                            if (_hotKeyStates.ContainsKey(hotKeyId) && _hotKeyStates[hotKeyId])
+                            {
+                                _hotKeyStates[hotKeyId] = false;
+                                _vkCodeToHotKeyId.Remove(vkCode);
+
+                                if (_registeredHotKeys.TryGetValue(hotKeyId, out var hotKeyInfo))
+                                {
+                                    // Dispatch to UI thread
+                                    _window?.Dispatcher.BeginInvoke(new Action(() =>
+                                    {
+                                        var args = new HotKeyEventArgs
+                                        {
+                                            HotKeyId = hotKeyId,
+                                            Key = hotKeyInfo.Key,
+                                            Modifiers = hotKeyInfo.Modifiers
+                                        };
+
+                                        HotKeyReleased?.Invoke(this, args);
+                                        hotKeyInfo.OnKeyUp?.Invoke();
+                                    }));
+                                }
+                            }
+                        }
+                    }
                 }
             }
+
+            // Always call the next hook - this ensures keys work in other applications
+            return CallNextHookEx(_hookId, nCode, wParam, lParam);
         }
 
         /// <summary>
-        /// Checks if a key combination is currently pressed
+        /// Gets the current modifier keys state
         /// </summary>
-        private bool IsKeyCombinationPressed(ModifierKeys modifiers, Key key)
+        private ModifierKeys GetCurrentModifiers()
         {
-            // Check modifiers
-            if ((modifiers & ModifierKeys.Control) == ModifierKeys.Control)
-            {
-                if ((GetAsyncKeyState(VK_CONTROL) & 0x8000) == 0)
-                    return false;
-            }
-
-            if ((modifiers & ModifierKeys.Shift) == ModifierKeys.Shift)
-            {
-                if ((GetAsyncKeyState(VK_SHIFT) & 0x8000) == 0)
-                    return false;
-            }
-
-            if ((modifiers & ModifierKeys.Alt) == ModifierKeys.Alt)
-            {
-                if ((GetAsyncKeyState(VK_MENU) & 0x8000) == 0)
-                    return false;
-            }
-
-            // Check the main key
-            int vkCode = KeyInterop.VirtualKeyFromKey(key);
-            if ((GetAsyncKeyState(vkCode) & 0x8000) == 0)
-                return false;
-
-            return true;
+            ModifierKeys modifiers = ModifierKeys.None;
+
+            if ((GetAsyncKeyState(VK_CONTROL) & 0x8000) != 0)
+                modifiers |= ModifierKeys.Control;
+            if ((GetAsyncKeyState(VK_SHIFT) & 0x8000) != 0)
+                modifiers |= ModifierKeys.Shift;
+            if ((GetAsyncKeyState(VK_MENU) & 0x8000) != 0)
+                modifiers |= ModifierKeys.Alt;
+            if ((GetAsyncKeyState((int)Key.LWin) & 0x8000) != 0 || (GetAsyncKeyState((int)Key.RWin) & 0x8000) != 0)
+                modifiers |= ModifierKeys.Windows;
+
+            return modifiers;
         }
 
         /// <summary>
@@ -393,25 +380,20 @@ private bool IsKeyCombinationPressed(ModifierKeys modifiers, Key key)
         /// </summary>
         public void Dispose()
         {
-            // Stop the key state timer
-            if (_keyStateTimer != null)
+            // Unhook the keyboard hook
+            if (_hookId != IntPtr.Zero)
             {
-                _keyStateTimer.Stop();
-                _keyStateTimer.Dispose();
-                _keyStateTimer = null;
+                UnhookWindowsHookEx(_hookId);
+                _hookId = IntPtr.Zero;
+                Console.WriteLine("Keyboard hook uninstalled.");
             }
 
             UnregisterAllHotKeys();
 
-            if (_hwndSource != null)
-            {
-                _hwndSource.RemoveHook(HwndHook);
-                _hwndSource.Dispose();
-            }
-
             _window = null;
             _windowHandle = IntPtr.Zero;
-            _hwndSource = null;
+            _currentlyPressedVKs.Clear();
+            _vkCodeToHotKeyId.Clear();
         }
     }
-}
+}
\ No newline at end of file
diff --git a/WhackerLinkConsoleV2/KeybindingConfigWindow.xaml b/WhackerLinkConsoleV2/KeybindingConfigWindow.xaml
index 2207ca8..84d3ef2 100644
--- a/WhackerLinkConsoleV2/KeybindingConfigWindow.xaml
+++ b/WhackerLinkConsoleV2/KeybindingConfigWindow.xaml
@@ -14,6 +14,10 @@
         <!-- Global PTT Section -->
         <TextBlock Text="Global PTT Keybind" FontWeight="Bold" Margin="0,0,0,5" Grid.Row="0"/>
         <Grid Grid.Row="1" Margin="0,5,0,15">
+            <Grid.RowDefinitions>
+                <RowDefinition Height="Auto"/>
+                <RowDefinition Height="Auto"/>
+            </Grid.RowDefinitions>
             <Grid.ColumnDefinitions>
                 <ColumnDefinition Width="*"/>
                 <ColumnDefinition Width="Auto"/>
@@ -26,6 +30,7 @@
                      VerticalContentAlignment="Center"
                      Padding="5"
                      Grid.Column="0"
+                     Grid.Row="0"
                      Margin="0,0,10,0"/>
             
             <Button x:Name="RecordGlobalPttButton" 
@@ -33,13 +38,25 @@
                     Content="Record" 
                     Width="80" 
                     Margin="0,0,10,0"
-                    Grid.Column="1"/>
+                    Grid.Column="1"
+                    Grid.Row="0"/>
             
             <Button x:Name="ClearGlobalPttButton" 
                     Click="ClearGlobalPtt_Click" 
                     Content="Clear" 
                     Width="80"
-                    Grid.Column="2"/>
+                    Grid.Column="2"
+                    Grid.Row="0"/>
+            
+            <!-- Hotkeys work when unfocused checkbox -->
+            <CheckBox x:Name="HotkeysWorkWhenUnfocusedCheckbox"
+                      Content="Allow hotkeys to work when application is not focused (tabbed out)"
+                      Grid.Column="0"
+                      Grid.ColumnSpan="3"
+                      Grid.Row="1"
+                      Margin="0,10,0,0"
+                      VerticalAlignment="Center"
+                      IsChecked="True"/>
         </Grid>
 
         <!-- Tabbed Section for Per-Channel Keybindings -->
diff --git a/WhackerLinkConsoleV2/KeybindingConfigWindow.xaml.cs b/WhackerLinkConsoleV2/KeybindingConfigWindow.xaml.cs
index 4512b2e..24630c2 100644
--- a/WhackerLinkConsoleV2/KeybindingConfigWindow.xaml.cs
+++ b/WhackerLinkConsoleV2/KeybindingConfigWindow.xaml.cs
@@ -73,6 +73,9 @@ private void LoadSettings()
         {
             // Load global keybinding
             GlobalPttKeybindDisplay.Text = _settingsManager.GlobalPttKeybind;
+            
+            // Load hotkeys work when unfocused setting
+            HotkeysWorkWhenUnfocusedCheckbox.IsChecked = _settingsManager.HotkeysWorkWhenUnfocused;
 
             // Load codeplug identifier for both tabs
             CodeplugIdentifierText.Text = _codeplugIdentifier;
@@ -512,8 +515,12 @@ private void Apply_Click(object sender, RoutedEventArgs e)
                     MessageBox.Show("Invalid Global PTT keybinding format.", "Validation Error", MessageBoxButton.OK, MessageBoxImage.Warning);
                     return;
                 }
+                
                 _settingsManager.GlobalPttKeybind = GlobalPttKeybindDisplay.Text;
             }
+            
+            // Save the hotkeys work when unfocused setting
+            _settingsManager.HotkeysWorkWhenUnfocused = HotkeysWorkWhenUnfocusedCheckbox.IsChecked ?? true;
 
             _settingsManager.SaveSettings();
 
@@ -535,6 +542,7 @@ private void Apply_Click(object sender, RoutedEventArgs e)
                         MessageBox.Show($"Invalid PTT keybinding for channel '{channelName}': {keybinding}", "Validation Error", MessageBoxButton.OK, MessageBoxImage.Warning);
                         return;
                     }
+                    
                     _channelKeybindingManager.SetChannelKeybinding(_codeplugIdentifier, channelName, keybinding);
                 }
             }
@@ -557,6 +565,7 @@ private void Apply_Click(object sender, RoutedEventArgs e)
                         MessageBox.Show($"Invalid toggle keybinding for channel '{channelName}': {keybinding}", "Validation Error", MessageBoxButton.OK, MessageBoxImage.Warning);
                         return;
                     }
+                    
                     _channelKeybindingManager.SetChannelToggleKeybinding(_codeplugIdentifier, channelName, keybinding);
                 }
             }
diff --git a/WhackerLinkConsoleV2/MainWindow.xaml.cs b/WhackerLinkConsoleV2/MainWindow.xaml.cs
index 0e2550b..4a35082 100644
--- a/WhackerLinkConsoleV2/MainWindow.xaml.cs
+++ b/WhackerLinkConsoleV2/MainWindow.xaml.cs
@@ -669,6 +669,9 @@ private void InitializeGlobalHotkeys()
                     _globalHotKeyManager = new GlobalHotKeyManager();
                     _globalHotKeyManager.Initialize(this);
                 }
+                
+                // Update the WorkWhenUnfocused setting
+                _globalHotKeyManager.WorkWhenUnfocused = _settingsManager.HotkeysWorkWhenUnfocused;
 
                 // Unregister old hotkey
                 if (_globalPttHotKeyId != -1)
diff --git a/WhackerLinkConsoleV2/SettingsManager.cs b/WhackerLinkConsoleV2/SettingsManager.cs
index 1736e7d..765703e 100644
--- a/WhackerLinkConsoleV2/SettingsManager.cs
+++ b/WhackerLinkConsoleV2/SettingsManager.cs
@@ -43,6 +43,9 @@ public class SettingsManager
         // Supports both single-key (e.g., "T", "P") and dual-key (e.g., "Ctrl+T", "Ctrl+P")
         public string GlobalPttKeybind { get; set; } = "Ctrl+T";          // Global PTT across all selected channels
         public bool EnableGlobalPttHotkey { get; set; } = true;
+        
+        // Controls whether hotkeys work when the application is not focused/tabbed out
+        public bool HotkeysWorkWhenUnfocused { get; set; } = true;
 
         public void LoadSettings()
         {
@@ -66,6 +69,7 @@ public void LoadSettings()
                     ChannelOutputDevices = loadedSettings.ChannelOutputDevices ?? new Dictionary<string, int>();
                     GlobalPttKeybind = loadedSettings.GlobalPttKeybind ?? "Ctrl+T";
                     EnableGlobalPttHotkey = loadedSettings.EnableGlobalPttHotkey;
+                    HotkeysWorkWhenUnfocused = loadedSettings.HotkeysWorkWhenUnfocused;
                 }
             }
             catch (Exception ex)

From 148fa362e4c34f8bf9d285705e3231bbfddc0ec3 Mon Sep 17 00:00:00 2001
From: Firav <firavv@gmail.com>
Date: Tue, 17 Mar 2026 08:09:14 -0400
Subject: [PATCH 13/13] fix formatting

---
 WhackerLinkConsoleV2/KeybindingParser.cs | 142 ++++++++++++-----------
 1 file changed, 72 insertions(+), 70 deletions(-)

diff --git a/WhackerLinkConsoleV2/KeybindingParser.cs b/WhackerLinkConsoleV2/KeybindingParser.cs
index 71b6525..a9eb66b 100644
--- a/WhackerLinkConsoleV2/KeybindingParser.cs
+++ b/WhackerLinkConsoleV2/KeybindingParser.cs
@@ -30,100 +30,102 @@ namespace WhackerLinkConsoleV2
     /// </summary>
     public static class KeybindingParser
     {
-    /// <summary>
-    /// Parses a keybinding string like "Ctrl+Alt+P" into ModifierKeys and Key
-    /// </summary>
-    /// <returns>Returns true if parsing was successful</returns>
-    public static bool TryParseKeybinding(string keybindingString, out ModifierKeys modifiers, out Key key)
-    {
-        modifiers = ModifierKeys.None;
-        key = Key.None;
-
-        if (string.IsNullOrWhiteSpace(keybindingString))
-        {
-            Console.WriteLine("ERROR: Keybinding string is null or empty");
-            return false;
-        }
-
-        try
+        /// <summary>
+        /// Parses a keybinding string like "Ctrl+Alt+P" into ModifierKeys and Key
+        /// </summary>
+        /// <returns>Returns true if parsing was successful</returns>
+        public static bool TryParseKeybinding(string keybindingString, out ModifierKeys modifiers, out Key key)
         {
-            var parts = keybindingString.Split('+');
+            modifiers = ModifierKeys.None;
+            key = Key.None;
 
-            if (parts.Length == 0)
+            if (string.IsNullOrWhiteSpace(keybindingString))
             {
-                Console.WriteLine($"ERROR: Invalid keybinding format: '{keybindingString}'");
+                Console.WriteLine("ERROR: Keybinding string is null or empty");
                 return false;
             }
 
-            // Handle single-key keybindings (e.g., "T", "P", "F1")
-            if (parts.Length == 1)
+            try
             {
-                string keyString = parts[0].Trim();
-                if (!Enum.TryParse<Key>(keyString, true, out key))
+                var parts = keybindingString.Split('+');
+
+                if (parts.Length == 0)
                 {
-                    Console.WriteLine($"ERROR: Unknown key: '{keyString}'");
+                    Console.WriteLine($"ERROR: Invalid keybinding format: '{keybindingString}'");
                     return false;
                 }
 
-                if (key == Key.None)
+                // Handle single-key keybindings (e.g., "T", "P", "F1")
+                if (parts.Length == 1)
                 {
-                    Console.WriteLine($"ERROR: Key cannot be None");
-                    return false;
+                    string keyString = parts[0].Trim();
+                    if (!Enum.TryParse<Key>(keyString, true, out key))
+                    {
+                        Console.WriteLine($"ERROR: Unknown key: '{keyString}'");
+                        return false;
+                    }
+
+                    if (key == Key.None)
+                    {
+                        Console.WriteLine($"ERROR: Key cannot be None");
+                        return false;
+                    }
+
+                    return true;
                 }
 
-                return true;
-            }
+                // Handle multi-key keybindings (e.g., "Ctrl+T", "Ctrl+Alt+P")
+                // Parse modifiers from all but the last part
+                for (int i = 0; i < parts.Length - 1; i++)
+                {
+                    string part = parts[i].Trim().ToLower();
+
+                    switch (part)
+                    {
+                        case "ctrl":
+                        case "control":
+                            modifiers |= ModifierKeys.Control;
+                            break;
+                        case "alt":
+                            modifiers |= ModifierKeys.Alt;
+                            break;
+                        case "shift":
+                            modifiers |= ModifierKeys.Shift;
+                            break;
+                        case "win":
+                        case "windows":
+                            modifiers |= ModifierKeys.Windows;
+                            break;
+                        default:
+                            Console.WriteLine($"ERROR: Unknown modifier key: '{part}'");
+                            return false;
+                    }
+                }
 
-            // Handle multi-key keybindings (e.g., "Ctrl+T", "Ctrl+Alt+P")
-            // Parse modifiers from all but the last part
-            for (int i = 0; i < parts.Length - 1; i++)
-            {
-                string part = parts[i].Trim().ToLower();
+                // Parse the main key from the last part
+                string keyStr = parts[parts.Length - 1].Trim();
+                if (!Enum.TryParse<Key>(keyStr, true, out key))
+                {
+                    Console.WriteLine($"ERROR: Unknown key: '{keyStr}'");
+                    return false;
+                }
 
-                switch (part)
+                if (key == Key.None)
                 {
-                    case "ctrl":
-                    case "control":
-                        modifiers |= ModifierKeys.Control;
-                        break;
-                    case "alt":
-                        modifiers |= ModifierKeys.Alt;
-                        break;
-                    case "shift":
-                        modifiers |= ModifierKeys.Shift;
-                        break;
-                    case "win":
-                    case "windows":
-                        modifiers |= ModifierKeys.Windows;
-                        break;
-                    default:
-                        Console.WriteLine($"ERROR: Unknown modifier key: '{part}'");
-                        return false;
+                    Console.WriteLine($"ERROR: Key cannot be None");
+                    return false;
                 }
-            }
 
-            // Parse the main key from the last part
-            string keyStr = parts[parts.Length - 1].Trim();
-            if (!Enum.TryParse<Key>(keyStr, true, out key))
-            {
-                Console.WriteLine($"ERROR: Unknown key: '{keyStr}'");
-                return false;
+                return true;
             }
-
-            if (key == Key.None)
+            catch (Exception ex)
             {
-                Console.WriteLine($"ERROR: Key cannot be None");
+                Console.WriteLine($"ERROR: Exception parsing keybinding '{keybindingString}': {ex.Message}");
                 return false;
             }
-
-            return true;
         }
-        catch (Exception ex)
-        {
-            Console.WriteLine($"ERROR: Exception parsing keybinding '{keybindingString}': {ex.Message}");
-            return false;
-        }
-    }        /// <summary>
+
+        /// <summary>
         /// Converts ModifierKeys and Key back to a keybinding string
         /// </summary>
         public static string KeybindingToString(ModifierKeys modifiers, Key key)