//

// Copyright (C) 2014-2015 Stéphane Lenclud.

//

// This file is part of SharpDisplayManager.

//

// SharpDisplayManager 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.

//

// SharpDisplayManager 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 SharpDisplayManager.  If not, see <http://www.gnu.org/licenses/>.

//

using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Data;

using System.Drawing;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using System.Windows.Forms;

using System.IO;

using CodeProject.Dialog;

using System.Drawing.Imaging;

using System.ServiceModel;

using System.Threading;

using System.Diagnostics;

using System.Deployment.Application;

using System.Reflection;

//NAudio

using NAudio.CoreAudioApi;

using NAudio.CoreAudioApi.Interfaces;

using System.Runtime.InteropServices;

using CecSharp;

//Network

using NETWORKLIST;

//

using SharpDisplayClient;

using SharpDisplay;

using MiniDisplayInterop;

using SharpLib.Display;

using Ear = SharpLib.Ear;

namespace SharpDisplayManager

{

    //Types declarations

    public delegate uint ColorProcessingDelegate(int aX, int aY, uint aPixel);

    public delegate int CoordinateTranslationDelegate(System.Drawing.Bitmap aBmp, int aInt);

    //Delegates are used for our thread safe method

    public delegate void AddClientDelegate(string aSessionId, ICallback aCallback);

    public delegate void RemoveClientDelegate(string aSessionId);

    public delegate void SetFieldDelegate(string SessionId, DataField aField);

    public delegate void SetFieldsDelegate(string SessionId, System.Collections.Generic.IList<DataField> aFields);

    public delegate void SetLayoutDelegate(string SessionId, TableLayout aLayout);

    public delegate void SetClientNameDelegate(string aSessionId, string aName);

    public delegate void SetClientPriorityDelegate(string aSessionId, uint aPriority);

    public delegate void PlainUpdateDelegate();

    public delegate void WndProcDelegate(ref Message aMessage);

    /// <summary>

    /// Our Display manager main form

    /// </summary>

    [System.ComponentModel.DesignerCategory("Form")]

    public partial class FormMain : FormMainHid, IMMNotificationClient

    {

        //public Manager iManager = new Manager();        

        DateTime LastTickTime;

        Display iDisplay;

        System.Drawing.Bitmap iBmp;

        bool iCreateBitmap; //Workaround render to bitmap issues when minimized

        ServiceHost iServiceHost;

        // Our collection of clients sorted by session id.

        public Dictionary<string, ClientData> iClients;

        // The name of the client which informations are currently displayed.

        public string iCurrentClientSessionId;

        ClientData iCurrentClientData;

        //

        public bool iClosing;

        //

        public bool iSkipFrameRendering;

        //Function pointer for pixel color filtering

        ColorProcessingDelegate iColorFx;

        //Function pointer for pixel X coordinate intercept

        CoordinateTranslationDelegate iScreenX;

        //Function pointer for pixel Y coordinate intercept

        CoordinateTranslationDelegate iScreenY;

        //NAudio

        private MMDeviceEnumerator iMultiMediaDeviceEnumerator;

        private MMDevice iMultiMediaDevice;

        //Network

        private NetworkManager iNetworkManager;

        /// <summary>

        /// CEC - Consumer Electronic Control.

        /// Notably used to turn TV on and off as Windows broadcast monitor on and off notifications.

        /// </summary>

        private ConsumerElectronicControl iCecManager;

        /// <summary>

        /// Manage run when Windows startup option

        /// </summary>

        private StartupManager iStartupManager;

        /// <summary>

        /// System notification icon used to hide our application from the task bar.

        /// </summary>

        private SharpLib.Notification.Control iNotifyIcon;

        /// <summary>

        /// System recording notification icon.

        /// </summary>

        private SharpLib.Notification.Control iRecordingNotification;

        /// <summary>

        /// 

        /// </summary>

        RichTextBoxTextWriter iWriter;

        /// <summary>

        /// Allow user to receive window messages;

        /// </summary>

        public event WndProcDelegate OnWndProc;

        public FormMain()

        {

            if (Properties.Settings.Default.EarManager == null)

            {

                //No actions in our settings yet

                Properties.Settings.Default.EarManager = new EarManager();

            }

            else

            {

                // We loaded events and actions from our settings

                // Internalizer apparently skips constructor so we need to initialize it here

                // Though I reckon that should only be needed when loading an empty EAR manager I guess.

                Properties.Settings.Default.EarManager.Construct();

            }

            iSkipFrameRendering = false;

            iClosing = false;

            iCurrentClientSessionId = "";

            iCurrentClientData = null;

            LastTickTime = DateTime.Now;

            //Instantiate our display and register for events notifications

            iDisplay = new Display();

            iDisplay.OnOpened += OnDisplayOpened;

            iDisplay.OnClosed += OnDisplayClosed;

            //

            iClients = new Dictionary<string, ClientData>();

            iStartupManager = new StartupManager();

            iNotifyIcon = new SharpLib.Notification.Control();

            iRecordingNotification = new SharpLib.Notification.Control();

            //Have our designer initialize its controls

            InitializeComponent();

            //Redirect console output

            iWriter = new RichTextBoxTextWriter(richTextBoxLogs);

            Console.SetOut(iWriter);

            //Populate device types

            PopulateDeviceTypes();

            //Initial status update 

            UpdateStatus();

            //We have a bug when drawing minimized and reusing our bitmap

            //Though I could not reproduce it on Windows 10

            iBmp = new System.Drawing.Bitmap(iTableLayoutPanel.Width, iTableLayoutPanel.Height,

                PixelFormat.Format32bppArgb);

            iCreateBitmap = false;

            //Minimize our window if desired

            if (Properties.Settings.Default.StartMinimized)

            {

                WindowState = FormWindowState.Minimized;

            }

        }

        /// <summary>

        ///

        /// </summary>

        /// <param name="sender"></param>

        /// <param name="e"></param>

        private void MainForm_Load(object sender, EventArgs e)

        {

            //Check if we are running a Click Once deployed application

            if (ApplicationDeployment.IsNetworkDeployed)

            {

                //This is a proper Click Once installation, fetch and show our version number

                this.Text += " - v" + ApplicationDeployment.CurrentDeployment.CurrentVersion;

            }

            else

            {

                //Not a proper Click Once installation, assuming development build then

                this.Text += " - development";

            }

            //NAudio

            iMultiMediaDeviceEnumerator = new MMDeviceEnumerator();

            iMultiMediaDeviceEnumerator.RegisterEndpointNotificationCallback(this);

            UpdateAudioDeviceAndMasterVolumeThreadSafe();

            //Network

            iNetworkManager = new NetworkManager();

            iNetworkManager.OnConnectivityChanged += OnConnectivityChanged;

            UpdateNetworkStatus();

            //CEC

            iCecManager = new ConsumerElectronicControl();

            OnWndProc += iCecManager.OnWndProc;

            ResetCec();

            //Harmony

            ResetHarmony();

            //Setup Events

            PopulateEventsTreeView();

            //Setup notification icon

            SetupTrayIcon();

            //Setup recording notification

            SetupRecordingNotification();

            // To make sure start up with minimize to tray works

            if (WindowState == FormWindowState.Minimized && Properties.Settings.Default.MinimizeToTray)

            {

                Visible = false;

            }

#if !DEBUG

    //When not debugging we want the screen to be empty until a client takes over

			ClearLayout();

#else

            //When developing we want at least one client for testing

            StartNewClient("abcdefghijklmnopqrst-0123456789", "ABCDEFGHIJKLMNOPQRST-0123456789");

#endif

            //Open display connection on start-up if needed

            if (Properties.Settings.Default.DisplayConnectOnStartup)

            {

                OpenDisplayConnection();

            }

            //Start our server so that we can get client requests

            StartServer();

            //Register for HID events

            RegisterHidDevices();

            //Start Idle client if needed

            if (Properties.Settings.Default.StartIdleClient)

            {

                StartIdleClient();

            }

        }

        /// <summary>

        /// Called when our display is opened.

        /// </summary>

        /// <param name="aDisplay"></param>

        private void OnDisplayOpened(Display aDisplay)

        {

            //Make sure we resume frame rendering

            iSkipFrameRendering = false;

            //Set our screen size now that our display is connected

            //Our panelDisplay is the container of our tableLayoutPanel

            //tableLayoutPanel will resize itself to fit the client size of our panelDisplay

            //panelDisplay needs an extra 2 pixels for borders on each sides

            //tableLayoutPanel will eventually be the exact size of our display

            Size size = new Size(iDisplay.WidthInPixels() + 2, iDisplay.HeightInPixels() + 2);

            panelDisplay.Size = size;

            //Our display was just opened, update our UI

            UpdateStatus();

            //Initiate asynchronous request

            iDisplay.RequestFirmwareRevision();

            //Audio

            UpdateMasterVolumeThreadSafe();

            //Network

            UpdateNetworkStatus();

#if DEBUG

            //Testing icon in debug, no arm done if icon not supported

            //iDisplay.SetIconStatus(Display.TMiniDisplayIconType.EMiniDisplayIconRecording, 0, 1);

            //iDisplay.SetAllIconsStatus(2);

#endif

        }

        /// <summary>

        /// Populate tree view with events and actions

        /// </summary>

        private void PopulateEventsTreeView()

        {

            //Disable action buttons

            buttonActionAdd.Enabled = false;

            buttonActionDelete.Enabled = false;

            Ear.Event currentEvent = CurrentEvent();

            Ear.Action currentAction = CurrentAction();

            TreeNode treeNodeToSelect = null;

            //Reset our tree

            iTreeViewEvents.Nodes.Clear();

            //Populate registered events

            foreach (Ear.Event e in Properties.Settings.Default.EarManager.Events)

            {

                //Create our event node

                TreeNode eventNode = iTreeViewEvents.Nodes.Add(e.Brief());

                eventNode.Tag = e; //For easy access to our event

                if (!e.Enabled)

                {

                    //Dim our nodes if disabled

                    eventNode.ForeColor = Color.DimGray;

                }

                //Add event description as child node

                eventNode.Nodes.Add(e.Description).ForeColor = eventNode.ForeColor; 

                //Create child node for actions root

                TreeNode actionsNodes = eventNode.Nodes.Add("Actions");

                actionsNodes.ForeColor = eventNode.ForeColor;

                // Add our actions for that event

                foreach (Ear.Action a in e.Actions)

                {

                    TreeNode actionNode = actionsNodes.Nodes.Add(a.Brief());

                    actionNode.Tag = a;

                    actionNode.ForeColor = eventNode.ForeColor;

                    if (a == currentAction)

                    {

                        treeNodeToSelect = actionNode;

                    }

                }

            }

            iTreeViewEvents.ExpandAll();

            SelectEvent(currentEvent);

            if (treeNodeToSelect != null)

            {

                iTreeViewEvents.SelectedNode = treeNodeToSelect;

            }

            else if (iTreeViewEvents.SelectedNode != null && iTreeViewEvents.SelectedNode.Nodes[1].GetNodeCount(false) > 0)

            {

                //Select the last action if any 

                iTreeViewEvents.SelectedNode =

                    iTreeViewEvents.SelectedNode.Nodes[1].Nodes[

                        iTreeViewEvents.SelectedNode.Nodes[1].GetNodeCount(false) - 1];

            }

            else if (iTreeViewEvents.SelectedNode == null && iTreeViewEvents.Nodes.Count > 0)

            {

                //Still no selected node select the first one then

                iTreeViewEvents.SelectedNode = iTreeViewEvents.Nodes[0];

            }

            UpdateEventView();

        }

        /// <summary>

        /// Called when our display is closed.

        /// </summary>

        /// <param name="aDisplay"></param>

        private void OnDisplayClosed(Display aDisplay)

        {

            //Our display was just closed, update our UI consequently

            UpdateStatus();

        }

        public void OnConnectivityChanged(NetworkManager aNetwork, NLM_CONNECTIVITY newConnectivity)

        {

            //Update network status

            UpdateNetworkStatus();

        }

        /// <summary>

        /// Update our Network Status

        /// </summary>

        private void UpdateNetworkStatus()

        {

            if (iDisplay.IsOpen())

            {

                iDisplay.SetIconOnOff(MiniDisplay.IconType.Internet,

                    iNetworkManager.NetworkListManager.IsConnectedToInternet);

                iDisplay.SetIconOnOff(MiniDisplay.IconType.NetworkSignal, iNetworkManager.NetworkListManager.IsConnected);

            }

        }

        int iLastNetworkIconIndex = 0;

        int iUpdateCountSinceLastNetworkAnimation = 0;

        /// <summary>

        /// 

        /// </summary>

        private void UpdateNetworkSignal(DateTime aLastTickTime, DateTime aNewTickTime)

        {

            iUpdateCountSinceLastNetworkAnimation++;

            iUpdateCountSinceLastNetworkAnimation = iUpdateCountSinceLastNetworkAnimation%4;

            if (iDisplay.IsOpen() && iNetworkManager.NetworkListManager.IsConnected &&

                iUpdateCountSinceLastNetworkAnimation == 0)

            {

                int iconCount = iDisplay.IconCount(MiniDisplay.IconType.NetworkSignal);

                if (iconCount <= 0)

                {

                    //Prevents div by zero and other undefined behavior

                    return;

                }

                iLastNetworkIconIndex++;

                iLastNetworkIconIndex = iLastNetworkIconIndex%(iconCount*2);

                for (int i = 0; i < iconCount; i++)

                {

                    if (i < iLastNetworkIconIndex && !(i == 0 && iLastNetworkIconIndex > 3) &&

                        !(i == 1 && iLastNetworkIconIndex > 4))

                    {

                        iDisplay.SetIconOn(MiniDisplay.IconType.NetworkSignal, i);

                    }

                    else

                    {

                        iDisplay.SetIconOff(MiniDisplay.IconType.NetworkSignal, i);

                    }

                }

            }

        }

        /// <summary>

        /// Receive volume change notification and reflect changes on our slider.

        /// </summary>

        /// <param name="data"></param>

        public void OnVolumeNotificationThreadSafe(AudioVolumeNotificationData data)

        {

            UpdateMasterVolumeThreadSafe();

        }

        /// <summary>

        /// Update master volume when user moves our slider.

        /// </summary>

        /// <param name="sender"></param>

        /// <param name="e"></param>

        private void trackBarMasterVolume_Scroll(object sender, EventArgs e)

        {

            //Just like Windows Volume Mixer we unmute if the volume is adjusted

            iMultiMediaDevice.AudioEndpointVolume.Mute = false;

            //Set volume level according to our volume slider new position

            iMultiMediaDevice.AudioEndpointVolume.MasterVolumeLevelScalar = trackBarMasterVolume.Value/100.0f;

        }

        /// <summary>

        /// Mute check box changed.

        /// </summary>

        /// <param name="sender"></param>

        /// <param name="e"></param>

        private void checkBoxMute_CheckedChanged(object sender, EventArgs e)

        {

            iMultiMediaDevice.AudioEndpointVolume.Mute = checkBoxMute.Checked;

        }

        /// <summary>

        /// Device State Changed

        /// </summary>

        public void OnDeviceStateChanged([MarshalAs(UnmanagedType.LPWStr)] string deviceId,

            [MarshalAs(UnmanagedType.I4)] DeviceState newState)

        {

        }

        /// <summary>

        /// Device Added

        /// </summary>

        public void OnDeviceAdded([MarshalAs(UnmanagedType.LPWStr)] string pwstrDeviceId)

        {

        }

        /// <summary>

        /// Device Removed

        /// </summary>

        public void OnDeviceRemoved([MarshalAs(UnmanagedType.LPWStr)] string deviceId)

        {

        }

        /// <summary>

        /// Default Device Changed

        /// </summary>

        public void OnDefaultDeviceChanged(DataFlow flow, Role role,

            [MarshalAs(UnmanagedType.LPWStr)] string defaultDeviceId)

        {

            if (role == Role.Multimedia && flow == DataFlow.Render)

            {

                UpdateAudioDeviceAndMasterVolumeThreadSafe();

            }

        }

        /// <summary>

        /// Property Value Changed

        /// </summary>

        /// <param name="pwstrDeviceId"></param>

        /// <param name="key"></param>

        public void OnPropertyValueChanged([MarshalAs(UnmanagedType.LPWStr)] string pwstrDeviceId, PropertyKey key)

        {

        }

        /// <summary>

        /// Update master volume indicators based our current system states.

        /// This typically includes volume levels and mute status.

        /// </summary>

        private void UpdateMasterVolumeThreadSafe()

        {

            if (this.InvokeRequired)

            {

                //Not in the proper thread, invoke ourselves

                PlainUpdateDelegate d = new PlainUpdateDelegate(UpdateMasterVolumeThreadSafe);

                this.Invoke(d, new object[] {});

                return;

            }

            //Update volume slider

            float volumeLevelScalar = iMultiMediaDevice.AudioEndpointVolume.MasterVolumeLevelScalar;

            trackBarMasterVolume.Value = Convert.ToInt32(volumeLevelScalar*100);

            //Update mute checkbox

            checkBoxMute.Checked = iMultiMediaDevice.AudioEndpointVolume.Mute;

            //If our display connection is open we need to update its icons

            if (iDisplay.IsOpen())

            {

                //First take care our our volume level icons

                int volumeIconCount = iDisplay.IconCount(MiniDisplay.IconType.Volume);

                if (volumeIconCount > 0)

                {

                    //Compute current volume level from system level and the number of segments in our display volume bar.

                    //That tells us how many segments in our volume bar needs to be turned on.

                    float currentVolume = volumeLevelScalar*volumeIconCount;

                    int segmentOnCount = Convert.ToInt32(currentVolume);

                    //Check if our segment count was rounded up, this will later be used for half brightness segment

                    bool roundedUp = segmentOnCount > currentVolume;

                    for (int i = 0; i < volumeIconCount; i++)

                    {

                        if (i < segmentOnCount)

                        {

                            //If we are dealing with our last segment and our segment count was rounded up then we will use half brightness.

                            if (i == segmentOnCount - 1 && roundedUp)

                            {

                                //Half brightness

                                iDisplay.SetIconStatus(MiniDisplay.IconType.Volume, i,

                                    (iDisplay.IconStatusCount(MiniDisplay.IconType.Volume) - 1)/2);

                            }

                            else

                            {

                                //Full brightness

                                iDisplay.SetIconStatus(MiniDisplay.IconType.Volume, i,

                                    iDisplay.IconStatusCount(MiniDisplay.IconType.Volume) - 1);

                            }

                        }

                        else

                        {

                            iDisplay.SetIconStatus(MiniDisplay.IconType.Volume, i, 0);

                        }

                    }

                }

                //Take care of our mute icon

                iDisplay.SetIconOnOff(MiniDisplay.IconType.Mute, iMultiMediaDevice.AudioEndpointVolume.Mute);

            }

        }

        /// <summary>

        /// 

        /// </summary>

        private void UpdateAudioDeviceAndMasterVolumeThreadSafe()

        {

            if (this.InvokeRequired)

            {

                //Not in the proper thread, invoke ourselves

                PlainUpdateDelegate d = new PlainUpdateDelegate(UpdateAudioDeviceAndMasterVolumeThreadSafe);

                this.Invoke(d, new object[] {});

                return;

            }

            //We are in the correct thread just go ahead.

            try

            {

                //Get our master volume            

                iMultiMediaDevice = iMultiMediaDeviceEnumerator.GetDefaultAudioEndpoint(DataFlow.Render, Role.Multimedia);

                //Update our label

                labelDefaultAudioDevice.Text = iMultiMediaDevice.FriendlyName;

                //Show our volume in our track bar

                UpdateMasterVolumeThreadSafe();

                //Register to get volume modifications

                iMultiMediaDevice.AudioEndpointVolume.OnVolumeNotification += OnVolumeNotificationThreadSafe;

                //

                trackBarMasterVolume.Enabled = true;

            }

            catch (Exception ex)

            {

                Debug.WriteLine("Exception thrown in UpdateAudioDeviceAndMasterVolume");

                Debug.WriteLine(ex.ToString());

                //Something went wrong S/PDIF device ca throw exception I guess

                trackBarMasterVolume.Enabled = false;

            }

        }

        /// <summary>

        /// 

        /// </summary>

        private void PopulateDeviceTypes()

        {

            int count = Display.TypeCount();

            for (int i = 0; i < count; i++)

            {

                comboBoxDisplayType.Items.Add(Display.TypeName((MiniDisplay.Type) i));

            }

        }

        /// <summary>

        ///

        /// </summary>

        private void SetupTrayIcon()

        {

            iNotifyIcon.Icon = GetIcon("vfd.ico");

            iNotifyIcon.Text = "Sharp Display Manager";

            iNotifyIcon.Visible = true;

            //Double click toggles visibility - typically brings up the application

            iNotifyIcon.DoubleClick += delegate(object obj, EventArgs args)

            {

                SysTrayHideShow();

            };

            //Adding a context menu, useful to be able to exit the application

            ContextMenu contextMenu = new ContextMenu();

            //Context menu item to toggle visibility

            MenuItem hideShowItem = new MenuItem("Hide/Show");

            hideShowItem.Click += delegate(object obj, EventArgs args)

            {

                SysTrayHideShow();

            };

            contextMenu.MenuItems.Add(hideShowItem);

            //Context menu item separator

            contextMenu.MenuItems.Add(new MenuItem("-"));

            //Context menu exit item

            MenuItem exitItem = new MenuItem("Exit");

            exitItem.Click += delegate(object obj, EventArgs args)

            {

                Application.Exit();

            };

            contextMenu.MenuItems.Add(exitItem);

            iNotifyIcon.ContextMenu = contextMenu;

        }

        /// <summary>

        ///

        /// </summary>

        private void SetupRecordingNotification()

        {

            iRecordingNotification.Icon = GetIcon("record.ico");

            iRecordingNotification.Text = "No recording";

            iRecordingNotification.Visible = false;

        }

        /// <summary>

        /// Access icons from embedded resources.

        /// </summary>

        /// <param name="aName"></param>

        /// <returns></returns>

        public static Icon GetIcon(string aName)

        {

            string[] names = Assembly.GetExecutingAssembly().GetManifestResourceNames();

            foreach (string name in names)

            {

                //Find a resource name that ends with the given name

                if (name.EndsWith(aName))

                {

                    using (Stream stream = Assembly.GetExecutingAssembly().GetManifestResourceStream(name))

                    {

                        return new Icon(stream);

                    }

                }

            }

            return null;

        }

        /// <summary>

        /// Set our current client.

        /// This will take care of applying our client layout and set data fields.

        /// </summary>

        /// <param name="aSessionId"></param>

        void SetCurrentClient(string aSessionId, bool aForce = false)

        {

            if (aSessionId == iCurrentClientSessionId)

            {

                //Given client is already the current one.

                //Don't bother changing anything then.

                return;

            }

            ClientData requestedClientData = iClients[aSessionId];

            //Check when was the last time we switched to that client

            if (iCurrentClientData != null)

            {

                //Do not switch client if priority of current client is higher 

                if (!aForce && requestedClientData.Priority < iCurrentClientData.Priority)

                {

                    return;

                }

                double lastSwitchToClientSecondsAgo = (DateTime.Now - iCurrentClientData.LastSwitchTime).TotalSeconds;

                //TODO: put that hard coded value as a client property

                //Clients should be able to define how often they can be interrupted

                //Thus a background client can set this to zero allowing any other client to interrupt at any time

                //We could also compute this delay by looking at the requests frequencies?

                if (!aForce &&

                    requestedClientData.Priority == iCurrentClientData.Priority &&

                    //Time sharing is only if clients have the same priority

                    (lastSwitchToClientSecondsAgo < 30)) //Make sure a client is on for at least 30 seconds

                {

                    //Don't switch clients too often

                    return;

                }

            }

            //Set current client ID.

            iCurrentClientSessionId = aSessionId;

            //Set the time we last switched to that client

            iClients[aSessionId].LastSwitchTime = DateTime.Now;

            //Fetch and set current client data.

            iCurrentClientData = requestedClientData;

            //Apply layout and set data fields.

            UpdateTableLayoutPanel(iCurrentClientData);

        }

        private void buttonFont_Click(object sender, EventArgs e)

        {

            //fontDialog.ShowColor = true;

            //fontDialog.ShowApply = true;

            fontDialog.ShowEffects = true;

            fontDialog.Font = cds.Font;

            fontDialog.FixedPitchOnly = checkBoxFixedPitchFontOnly.Checked;

            //fontDialog.ShowHelp = true;

            //fontDlg.MaxSize = 40;

            //fontDlg.MinSize = 22;

            //fontDialog.Parent = this;

            //fontDialog.StartPosition = FormStartPosition.CenterParent;

            //DlgBox.ShowDialog(fontDialog);

            //if (fontDialog.ShowDialog(this) != DialogResult.Cancel)

            if (DlgBox.ShowDialog(fontDialog) != DialogResult.Cancel)

            {

                //Set the fonts to all our labels in our layout

                foreach (Control ctrl in iTableLayoutPanel.Controls)

                {

                    if (ctrl is MarqueeLabel)

                    {

                        ((MarqueeLabel) ctrl).Font = fontDialog.Font;

                    }

                }

                //Save font settings

                cds.Font = fontDialog.Font;

                Properties.Settings.Default.Save();

                //

                CheckFontHeight();

            }

        }

        /// <summary>

        ///

        /// </summary>

        void CheckFontHeight()

        {

            //Show font height and width

            labelFontHeight.Text = "Font height: " + cds.Font.Height;

            float charWidth = IsFixedWidth(cds.Font);

            if (charWidth == 0.0f)

            {

                labelFontWidth.Visible = false;

            }

            else

            {

                labelFontWidth.Visible = true;

                labelFontWidth.Text = "Font width: " + charWidth;

            }

            MarqueeLabel label = null;

            //Get the first label control we can find

            foreach (Control ctrl in iTableLayoutPanel.Controls)

            {

                if (ctrl is MarqueeLabel)

                {

                    label = (MarqueeLabel) ctrl;

                    break;

                }

            }

            //Now check font height and show a warning if needed.

            if (label != null && label.Font.Height > label.Height)

            {

                labelWarning.Text = "WARNING: Selected font is too height by " + (label.Font.Height - label.Height) +

                                    " pixels!";

                labelWarning.Visible = true;

            }

            else

            {

                labelWarning.Visible = false;

            }

        }

        private void buttonCapture_Click(object sender, EventArgs e)

        {

            System.Drawing.Bitmap bmp = new System.Drawing.Bitmap(iTableLayoutPanel.Width, iTableLayoutPanel.Height);

            iTableLayoutPanel.DrawToBitmap(bmp, iTableLayoutPanel.ClientRectangle);

            //Bitmap bmpToSave = new Bitmap(bmp);

            bmp.Save("D:\\capture.png");

            ((MarqueeLabel) iTableLayoutPanel.Controls[0]).Text = "Captured";

            /*

            string outputFileName = "d:\\capture.png";

            using (MemoryStream memory = new MemoryStream())

            {

                using (FileStream fs = new FileStream(outputFileName, FileMode.OpenOrCreate, FileAccess.ReadWrite))

                {

                    bmp.Save(memory, System.Drawing.Imaging.ImageFormat.Png);

                    byte[] bytes = memory.ToArray();

                    fs.Write(bytes, 0, bytes.Length);

                }

            }

             */

        }

        private void CheckForRequestResults()

        {

            if (iDisplay.IsRequestPending())

            {

                switch (iDisplay.AttemptRequestCompletion())

                {

                    case MiniDisplay.Request.FirmwareRevision:

                        toolStripStatusLabelConnect.Text += " v" + iDisplay.FirmwareRevision();

                        //Issue next request then

                        iDisplay.RequestPowerSupplyStatus();

                        break;

                    case MiniDisplay.Request.PowerSupplyStatus:

                        if (iDisplay.PowerSupplyStatus())

                        {

                            toolStripStatusLabelPower.Text = "ON";

                        }

                        else

                        {

                            toolStripStatusLabelPower.Text = "OFF";

                        }

                        //Issue next request then

                        iDisplay.RequestDeviceId();

                        break;

                    case MiniDisplay.Request.DeviceId:

                        toolStripStatusLabelConnect.Text += " - " + iDisplay.DeviceId();

                        //No more request to issue

                        break;

                }

            }

        }

        public static uint ColorWhiteIsOn(int aX, int aY, uint aPixel)

        {

            if ((aPixel & 0x00FFFFFF) == 0x00FFFFFF)

            {

                return 0xFFFFFFFF;

            }

            return 0x00000000;

        }

        public static uint ColorUntouched(int aX, int aY, uint aPixel)

        {

            return aPixel;

        }

        public static uint ColorInversed(int aX, int aY, uint aPixel)

        {

            return ~aPixel;

        }

        public static uint ColorChessboard(int aX, int aY, uint aPixel)

        {

            if ((aX%2 == 0) && (aY%2 == 0))

            {

                return ~aPixel;

            }

            else if ((aX%2 != 0) && (aY%2 != 0))

            {

                return ~aPixel;

            }

            return 0x00000000;

        }

        public static int ScreenReversedX(System.Drawing.Bitmap aBmp, int aX)

        {

            return aBmp.Width - aX - 1;

        }

        public int ScreenReversedY(System.Drawing.Bitmap aBmp, int aY)

        {

            return iBmp.Height - aY - 1;

        }

        public int ScreenX(System.Drawing.Bitmap aBmp, int aX)

        {

            return aX;

        }

        public int ScreenY(System.Drawing.Bitmap aBmp, int aY)

        {

            return aY;

        }

        /// <summary>

        /// Select proper pixel delegates according to our current settings.

        /// </summary>

        private void SetupPixelDelegates()

        {

            //Select our pixel processing routine

            if (cds.InverseColors)

            {

                //iColorFx = ColorChessboard;

                iColorFx = ColorInversed;

            }

            else

            {

                iColorFx = ColorWhiteIsOn;

            }

            //Select proper coordinate translation functions

            //We used delegate/function pointer to support reverse screen without doing an extra test on each pixels

            if (cds.ReverseScreen)

            {

                iScreenX = ScreenReversedX;

                iScreenY = ScreenReversedY;

            }

            else

            {

                iScreenX = ScreenX;

                iScreenY = ScreenY;

            }

        }

        //This is our timer tick responsible to perform our render