MainWindow.xaml.cs

// This is the "code-behind" file for your main window.
// It handles button clicks, populates the list, and calls the DisplayManager.
using Microsoft.UI.Xaml;
using Microsoft.UI.Xaml.Controls;
using System;
using System.IO;
using System.Linq;
using Microsoft.UI.Windowing; // Required for AppWindow
using System.Runtime.InteropServices; // Required for P/Invoke (API calls)
using WinRT.Interop; // Required for window handle interop

namespace MonPro
{
    public sealed partial class MainWindow : Window
    {
        // We will store profile .json files in a dedicated folder in the user's AppData directory.
        private readonly string _profilesPath;

        // New members for tray icon functionality
        private AppWindow _appWindow;
        private bool _isExiting = false;
        private IntPtr _hWnd = IntPtr.Zero;
        private delegate int SUBCLASSPROC(IntPtr hWnd, uint uMsg, IntPtr wParam, IntPtr lParam, IntPtr uIdSubclass, IntPtr dwRefData);
        private readonly SUBCLASSPROC _wndProcDelegate;

        public MainWindow()
        {
            this.InitializeComponent();
            this.Title = "Monitor Profile Manager";

            // --- New setup for tray icon and window handling ---
            _hWnd = WindowNative.GetWindowHandle(this);
            WindowId wndId = Microsoft.UI.Win32Interop.GetWindowIdFromWindow(_hWnd);
            _appWindow = AppWindow.GetFromId(wndId);

            // Intercept window messages for tray icon clicks
            _wndProcDelegate = new SUBCLASSPROC(SubclassProc);
            SetWindowSubclass(_hWnd, _wndProcDelegate, 0, 0);

            // Subscribe to the closing event to override it
            _appWindow.Closing += OnWindowClosing;
            // --- End of new setup ---

            // Define the path where profiles will be saved.
            string appDataPath = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
            _profilesPath = Path.Combine(appDataPath, "MonPro", "Profiles");

            // Ensure the directory exists.
            Directory.CreateDirectory(_profilesPath);

            // Load any existing profiles into the list when the app starts.
            RefreshProfilesList();
        }

        #region Core App Logic

        private void SaveProfileButton_Click(object sender, RoutedEventArgs e)
        {
            string profileName = ProfileNameTextBox.Text.Trim();
            if (string.IsNullOrWhiteSpace(profileName)) return;

            string safeFileName = string.Join("_", profileName.Split(Path.GetInvalidFileNameChars()));
            string filePath = Path.Combine(_profilesPath, $"{safeFileName}.json");

            DisplayManager.SaveCurrentProfile(filePath);

            ProfileNameTextBox.Text = "";
            RefreshProfilesList();
        }

        private void LoadProfileButton_Click(object sender, RoutedEventArgs e)
        {
            if (ProfileListView.SelectedItem is string profileName)
            {
                string filePath = Path.Combine(_profilesPath, $"{profileName}.json");
                DisplayManager.LoadProfile(filePath);
            }
        }

        private void DeleteProfileButton_Click(object sender, RoutedEventArgs e)
        {
            if (ProfileListView.SelectedItem is string profileName)
            {
                string filePath = Path.Combine(_profilesPath, $"{profileName}.json");
                if (File.Exists(filePath))
                {
                    File.Delete(filePath);
                }
                RefreshProfilesList();
            }
        }

        private void RefreshProfilesList()
        {
            ProfileListView.Items.Clear();
            var profileFiles = Directory.GetFiles(_profilesPath, "*.json");
            foreach (var file in profileFiles)
            {
                ProfileListView.Items.Add(Path.GetFileNameWithoutExtension(file));
            }
        }
        #endregion

        #region Tray Icon and Window Management

        /// <summary>
        /// Overrides the standard window closing behavior.
        /// </summary>
        private void OnWindowClosing(AppWindow sender, AppWindowClosingEventArgs args)
        {
            if (!_isExiting)
            {
                // Prevent the window from closing
                args.Cancel = true;

                // Add the icon to the tray and hide the main window
                AddTrayIcon();
                _appWindow.Hide();
            }
        }

        /// <summary>
        /// A custom message processor to handle clicks on our tray icon.
        /// </summary>
        private int SubclassProc(IntPtr hWnd, uint uMsg, IntPtr wParam, IntPtr lParam, IntPtr uIdSubclass, IntPtr dwRefData)
        {
            // Check if the message is from our tray icon
            if (uMsg == WM_TRAYICON)
            {
                // Check for mouse clicks
                if (lParam.ToInt32() == WM_LBUTTONUP) // Left-click to restore
                {
                    RestoreWindow();
                }
                else if (lParam.ToInt32() == WM_RBUTTONUP) // Right-click for context menu
                {
                    ShowContextMenu();
                }
            }
            // Pass messages on to the default processor
            return DefSubclassProc(hWnd, uMsg, wParam, lParam);
        }

        private void ShowContextMenu()
        {
            // Create a native Win32 popup menu
            IntPtr menu = CreatePopupMenu();
            AppendMenu(menu, MF_STRING, 1001, "Show");
            AppendMenu(menu, MF_STRING, 1002, "Exit");

            // Set position and show the menu
            GetCursorPos(out POINT pt);
            SetForegroundWindow(_hWnd);
            int command = TrackPopupMenu(menu, TPM_RETURNCMD, pt.x, pt.y, 0, _hWnd, IntPtr.Zero);

            // Handle the user's choice
            if (command == 1001) // Show
            {
                RestoreWindow();
            }
            else if (command == 1002) // Exit
            {
                ExitApplication();
            }

            DestroyMenu(menu);
        }

        private void RestoreWindow()
        {
            RemoveTrayIcon();
            _appWindow.Show();
        }

        private void ExitApplication()
        {
            _isExiting = true;
            RemoveTrayIcon();
            Application.Current.Exit();
        }

        private void AddTrayIcon()
        {
            var notifyIconData = new NOTIFYICONDATA();
            notifyIconData.cbSize = (uint)Marshal.SizeOf(notifyIconData);
            notifyIconData.hWnd = _hWnd;
            notifyIconData.uID = 1;
            notifyIconData.uFlags = NIF_ICON | NIF_MESSAGE | NIF_TIP;
            notifyIconData.uCallbackMessage = WM_TRAYICON;
            notifyIconData.szTip = "Monitor Profile Switcher";

            // IMPORTANT: This assumes you have an "icon.ico" file in your project's Assets folder.
            string iconPath = Path.Combine(AppContext.BaseDirectory, "Assets/icon.ico");
            notifyIconData.hIcon = LoadImage(IntPtr.Zero, iconPath, 1, 0, 0, 0x0010);

            Shell_NotifyIcon(NIM_ADD, ref notifyIconData);
        }

        private void RemoveTrayIcon()
        {
            var notifyIconData = new NOTIFYICONDATA();
            notifyIconData.cbSize = (uint)Marshal.SizeOf(notifyIconData);
            notifyIconData.hWnd = _hWnd;
            notifyIconData.uID = 1;
            Shell_NotifyIcon(NIM_DELETE, ref notifyIconData);
        }

        #endregion

        #region P/Invoke Definitions for Win32 API

        // Constants
        private const int WM_TRAYICON = 0x800;
        private const int WM_LBUTTONUP = 0x0202;
        private const int WM_RBUTTONUP = 0x0205;
        private const uint MF_STRING = 0x0000;
        private const uint TPM_RETURNCMD = 0x0100;
        private const uint NIM_ADD = 0x00;
        private const uint NIM_DELETE = 0x02;
        private const uint NIF_ICON = 0x02;
        private const uint NIF_MESSAGE = 0x01;
        private const uint NIF_TIP = 0x04;

        // Structures
        [StructLayout(LayoutKind.Sequential)]
        private struct POINT { public int x; public int y; }

        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
        private struct NOTIFYICONDATA
        {
            public uint cbSize;
            public IntPtr hWnd;
            public uint uID;
            public uint uFlags;
            public uint uCallbackMessage;
            public IntPtr hIcon;
            [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 128)]
            public string szTip;
        }

        // Functions
        [DllImport("user32.dll", SetLastError = true)]
        private static extern IntPtr LoadImage(IntPtr hinst, string lpszName, uint uType, int cxDesired, int cyDesired, uint fuLoad);
        [DllImport("shell32.dll")]
        private static extern bool Shell_NotifyIcon(uint dwMessage, ref NOTIFYICONDATA lpdata);
        [DllImport("user32.dll")]
        private static extern bool GetCursorPos(out POINT lpPoint);
        [DllImport("user32.dll")]
        private static extern IntPtr CreatePopupMenu();
        [DllImport("user32.dll")]
        private static extern bool AppendMenu(IntPtr hMenu, uint uFlags, uint uIDNewItem, string lpNewItem);
        [DllImport("user32.dll")]
        private static extern bool SetForegroundWindow(IntPtr hWnd);
        [DllImport("user32.dll")]
        private static extern int TrackPopupMenu(IntPtr hMenu, uint uFlags, int x, int y, int nReserved, IntPtr hWnd, IntPtr prcRect);
        [DllImport("user32.dll")]
        private static extern bool DestroyMenu(IntPtr hMenu);
        [DllImport("Comctl32.dll", SetLastError = true)]
        private static extern bool SetWindowSubclass(IntPtr hWnd, SUBCLASSPROC pfnSubclass, uint uIdSubclass, int dwRefData);
        [DllImport("Comctl32.dll", SetLastError = true)]
        private static extern int DefSubclassProc(IntPtr hWnd, uint uMsg, IntPtr wParam, IntPtr lParam);

        #endregion
    }
}