linear-app-launcher/MainForm.cs

using AppLauncher.Models;
using AppLauncher.Windows.Forms;
using Newtonsoft.Json;
using RyzStudio.Windows.Forms;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.IO;
using System.Runtime.InteropServices;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace AppLauncher
{
    public partial class MainForm : AForm
    {
        [DllImport("user32.dll")]
        protected static extern bool RegisterHotKey(IntPtr hWnd, int id, int fsModifiers, int vk);

        [DllImport("user32.dll")]
        protected static extern bool UnregisterHotKey(IntPtr hWnd, int id);

        protected const int MOD_ALT = 0x1;
        protected const int MOD_CONTROL = 0x2;
        protected const int MOD_SHIFT = 0x4;
        protected const int MOD_WIN = 0x8;
        protected const int WM_HOTKEY = 0x312;

        protected int collapsedWidth = 40;
        protected int expandedWidth = 800;

        protected string sessionFilename = null;

        public MainForm() : base()
        {
            InitializeComponent();

            //this.Visible = false;
        }

        protected override void OnLoad(EventArgs e)
        {
            base.OnLoad(e);

            RegisterHotKey((IntPtr)Handle, 1, (MOD_CONTROL | MOD_ALT), (int)Keys.F10);
        }

        protected override void OnShown(EventArgs e)
        {
            this.Visible = false;

            base.OnShown(e);

            string jsonfigFilename = Path.ChangeExtension(Application.ExecutablePath, "jsonfig");
            if (File.Exists(jsonfigFilename))
            {
                loadFile(jsonfigFilename);
            }

            this.Location = this.DefaultLocation;
            this.Visible = true;
        }

        protected override void OnClosing(CancelEventArgs e)
        {
            base.OnClosing(e);

            UnregisterHotKey((IntPtr)Handle, 1);

            if (string.IsNullOrWhiteSpace(sessionFilename))
            {
                // do nothing
            }
            else
            {
                DialogResult dr = MessageBox.Show("Save existing session?", "Exit", MessageBoxButtons.YesNoCancel, MessageBoxIcon.Question);
                if (dr == DialogResult.Yes)
                {
                    bool rv = saveFile(sessionFilename);
                    if (!rv)
                    {
                        e.Cancel = true;
                    }
                }
                else if (dr == DialogResult.No)
                {
                    // do nothing
                }
                else if (dr == DialogResult.Cancel)
                {
                    e.Cancel = true;
                }
            }
        }

        protected override void WndProc(ref Message m)
        {
            base.WndProc(ref m);

            if (m.Msg != WM_HOTKEY) return;

            switch (m.WParam.ToInt32())
            {
                case 1:
                    this.Visible = !this.Visible;
                    break;
                default: break;
            }
        }

        public async Task ToggleSize()
        {
            if (this.Width > collapsedWidth)
            {
                flowLayoutPanel1.Visible = false;

                await collapseWindow(collapsedWidth, 6);
            }
            else
            {
                await expandWindow(expandedWidth, 8);

                flowLayoutPanel1.Visible = true;
            }
        }

        /// <summary>
        /// New
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void toolStripMenuItem5_Click(object sender, EventArgs e)
        {
            if (string.IsNullOrWhiteSpace(sessionFilename))
            {
                newSession();
            }
            else
            {
                DialogResult dr = MessageBox.Show("Save existing session?", "New session", MessageBoxButtons.YesNoCancel, MessageBoxIcon.Question);
                if (dr == DialogResult.Yes)
                {
                    bool rv = saveFile(sessionFilename, false);
                    if (rv)
                    {
                        newSession();

                        sessionFilename = null;
                    }
                }
                else if (dr == DialogResult.No)
                {
                    newSession();

                    sessionFilename = null;
                }
                else if (dr == DialogResult.Cancel)
                {
                    return;
                }
            }
        }

        /// <summary>
        /// Open
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void toolStripMenuItem7_Click(object sender, EventArgs e)
        {
            if (string.IsNullOrWhiteSpace(sessionFilename))
            {
                if (openFileDialog1.ShowDialog() == DialogResult.OK)
                {
                    loadFile(openFileDialog1.FileName);
                }
            }
            else
            {
                DialogResult dr = MessageBox.Show("Save existing session?", "Open session", MessageBoxButtons.YesNoCancel, MessageBoxIcon.Question);
                if (dr == DialogResult.Yes)
                {
                    bool rv = saveFile(sessionFilename, false);
                    if (rv)
                    {
                        if (openFileDialog1.ShowDialog() == DialogResult.OK)
                        {
                            loadFile(openFileDialog1.FileName);
                        }
                    }
                }
                else if (dr == DialogResult.No)
                {
                    if (openFileDialog1.ShowDialog() == DialogResult.OK)
                    {
                        loadFile(openFileDialog1.FileName);
                    }
                }
                else if (dr == DialogResult.Cancel)
                {
                    return;
                }
            }
        }

        /// <summary>
        /// Close
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void toolStripMenuItem8_Click(object sender, EventArgs e)
        {
            if (string.IsNullOrWhiteSpace(sessionFilename))
            {
                flowLayoutPanel1.Controls.Clear();
            }
            else
            {
                DialogResult dr = MessageBox.Show("Save existing session?", "Close session", MessageBoxButtons.YesNoCancel, MessageBoxIcon.Question);
                if (dr == DialogResult.Yes)
                {
                    bool rv = saveFile(sessionFilename, false);
                    if (rv)
                    {
                        flowLayoutPanel1.Controls.Clear();

                        sessionFilename = null;
                    }
                }
                else if (dr == DialogResult.No)
                {
                    flowLayoutPanel1.Controls.Clear();

                    sessionFilename = null;
                }
                else if (dr == DialogResult.Cancel)
                {
                    return;
                }
            }
        }

        /// <summary>
        /// Save
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void toolStripMenuItem6_Click(object sender, EventArgs e)
        {
            if (string.IsNullOrWhiteSpace(sessionFilename))
            {
                saveAsFile();
            }
            else
            {
                saveFile(sessionFilename, true);
            }
        }

        /// <summary>
        /// Save As
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void toolStripMenuItem2_Click(object sender, EventArgs e) => saveAsFile();

        /// <summary>
        /// Always On Top
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void toolStripMenuItem1_Click(object sender, EventArgs e) => this.TopMost = !this.TopMost;

        /// <summary>
        /// Exit
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void exitToolStripMenuItem_Click(object sender, EventArgs e) => this.Close();

        protected async Task collapseWindow(int width, int increment = 6)
        {
            await Task.Run(() =>
            {
                while (this.Width > width)
                {
                    ThreadControl.SetWidth(this, (this.Width - increment));

                    Application.DoEvents();
                }

                ThreadControl.SetWidth(this, width);
            });
        }

        protected async Task expandWindow(int width, int increment = 8)
        {
            await Task.Run(() =>
            {
                while (this.Width < width)
                {
                    ThreadControl.SetWidth(this, (this.Width + increment));

                    Application.DoEvents();
                }

                ThreadControl.SetWidth(this, width);
            });
        }

        protected void loadFile(string filename)
        {
            if (isBusy)
            {
                return;
            }

            if (string.IsNullOrWhiteSpace(filename))
            {
                return;
            }

            if (!File.Exists(filename))
            {
                return;
            }

            string sourceCode = null;

            try
            {
                sessionFilename = filename;

                sourceCode = File.ReadAllText(sessionFilename);
            }
            catch (Exception exc)
            {
                MessageBox.Show(exc.Message, "Load session");
                return;
            }

            if (string.IsNullOrWhiteSpace(sourceCode))
            {
                return;
            }

            LauncherSession launcherSession = JsonConvert.DeserializeObject<LauncherSession>(sourceCode);
            if (launcherSession == null)
            {
                return;
            }

            int maxWidth = 0;
            flowLayoutPanel1.Controls.Clear();

            if (launcherSession.Groups != null)
            {
                foreach (TileGroupModel item in launcherSession.Groups)
                {
                    TTilePanelLayout panel = new TTilePanelLayout(item);
                    maxWidth = Math.Max(maxWidth, panel.Width);

                    flowLayoutPanel1.Controls.Add(panel);
                }
            }

            this.Width = maxWidth + SystemInformation.VerticalScrollBarWidth + 20 + flowLayoutPanel1.Left;
            this.Height = launcherSession.DefaultHeight;
        }

        protected void newSession()
        {
            int maxWidth = 0;
            flowLayoutPanel1.Controls.Clear();

            TTilePanelLayout panel = new TTilePanelLayout(new TileGroupModel()
            {
                Title = "New Group",
                IsExpanded = true,
                GridSize = new Size(8, 1)
            });

            maxWidth = Math.Max(maxWidth, panel.Width);

            flowLayoutPanel1.Controls.Add(panel);

            this.Width = maxWidth + SystemInformation.VerticalScrollBarWidth + 20 + flowLayoutPanel1.Left;
        }

        protected bool saveFile(string filename, bool showNotices = true)
        {
            if (isBusy)
            {
                return false;
            }

            if (string.IsNullOrWhiteSpace(filename))
            {
                return false;
            }

            if (flowLayoutPanel1.Controls.Count <= 0)
            {
                return true;
            }

            isBusy = true;

            LauncherSession launcherSession = new LauncherSession()
            {
                DefaultHeight = this.Height,
                Groups = new List<TileGroupModel>()
            };

            launcherSession.Groups = new List<TileGroupModel>();
            for (int i = 0; i < flowLayoutPanel1.Controls.Count; i++)
            {
                if (flowLayoutPanel1.Controls[i].GetType() != typeof(TTilePanelLayout))
                {
                    continue;
                }

                TTilePanelLayout container = flowLayoutPanel1.Controls[i] as TTilePanelLayout;
                launcherSession.Groups.Add(container.Model);
            }

            try
            {
                File.WriteAllText(filename, JsonConvert.SerializeObject(launcherSession));

                if (showNotices)
                {
                    MessageBox.Show("Session saved!", "Save session", MessageBoxButtons.OK, MessageBoxIcon.Information);
                }
            }
            catch (Exception exc)
            {
                MessageBox.Show(exc.Message, "Save session");

                return false;
            }

            isBusy = false;

            return true;
        }

        protected bool saveAsFile()
        {
            if (isBusy)
            {
                return false;
            }

            if (saveFileDialog1.ShowDialog() == DialogResult.OK)
            {
                bool rv = saveFile(saveFileDialog1.FileName);
                if (rv)
                {
                    sessionFilename = saveFileDialog1.FileName;
                }

                return rv;
            }

            return false;
        }

        private void contextMenuStrip1_Opening(object sender, System.ComponentModel.CancelEventArgs e)
        {
            toolStripMenuItem1.Checked = this.TopMost;
            toolStripMenuItem6.Enabled = !string.IsNullOrWhiteSpace(sessionFilename);
        }

    }
}