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;

//Network

using NETWORKLIST;

//

using SharpDisplayClient;

using SharpDisplay;

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 PlainUpdateDelegate();

    /// <summary>

    /// Our Display manager main form

    /// </summary>

	public partial class MainForm : Form, IMMNotificationClient

    {

        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;

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

		/// Manage run when Windows startup option

		/// </summary>

		private StartupManager iStartupManager;

		/// <summary>

		/// System tray icon.

		/// </summary>

		private NotifyIconAdv iNotifyIcon;

        public MainForm()

        {

            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 NotifyIconAdv();

			//Have our designer initialize its controls

            InitializeComponent();

			//Populate device types

			PopulateDeviceTypes();

			//Initial status update 

            UpdateStatus();

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

            iBmp = new System.Drawing.Bitmap(tableLayoutPanel.Width, tableLayoutPanel.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();

			//Setup notification icon

			SetupTrayIcon();

			// 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();

        }

		/// <summary>

		/// Called when our display is opened.

		/// </summary>

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

		private void OnDisplayOpened(Display aDisplay)

		{

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

		/// 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(Display.TMiniDisplayIconType.EMiniDisplayIconInternet, iNetworkManager.NetworkListManager.IsConnectedToInternet);

				iDisplay.SetIconOnOff(Display.TMiniDisplayIconType.EMiniDisplayIconNetworkSignal, 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(Display.TMiniDisplayIconType.EMiniDisplayIconNetworkSignal);

				iLastNetworkIconIndex++;

				iLastNetworkIconIndex = iLastNetworkIconIndex % (iconCount+1);

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

				{

					if (i < iLastNetworkIconIndex)

					{

						iDisplay.SetIconOn(Display.TMiniDisplayIconType.EMiniDisplayIconNetworkSignal,i);

					}

					else

					{

						iDisplay.SetIconOff(Display.TMiniDisplayIconType.EMiniDisplayIconNetworkSignal,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(Display.TMiniDisplayIconType.EMiniDisplayIconVolume);

				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(Display.TMiniDisplayIconType.EMiniDisplayIconVolume, i, (iDisplay.IconStatusCount(Display.TMiniDisplayIconType.EMiniDisplayIconVolume) - 1)/2);

							}

							else

							{

								//Full brightness

								iDisplay.SetIconStatus(Display.TMiniDisplayIconType.EMiniDisplayIconVolume, i, iDisplay.IconStatusCount(Display.TMiniDisplayIconType.EMiniDisplayIconVolume) - 1);

							}

						}

						else

						{

							iDisplay.SetIconStatus(Display.TMiniDisplayIconType.EMiniDisplayIconVolume, i, 0);

						}

					}

				}

				//Take care our our mute icon

				iDisplay.SetIconOnOff(Display.TMiniDisplayIconType.EMiniDisplayIconMute, 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((Display.TMiniDisplayType)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>

		/// Access icons from embedded resources.

		/// </summary>

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

		/// <returns></returns>

		public static Icon GetIcon(string name)

		{

			name = "SharpDisplayManager.Resources." + name;

			string[] names =

			  Assembly.GetExecutingAssembly().GetManifestResourceNames();

			for (int i = 0; i < names.Length; i++)

			{

				if (names[i].Replace('\\', '.') == name)

				{

					using (Stream stream = Assembly.GetExecutingAssembly().

					  GetManifestResourceStream(names[i]))

					{

						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)

        {

            if (aSessionId == iCurrentClientSessionId)

            {

                //Given client is already the current one.

                //Don't bother changing anything then.

                return;

            }

            //Set current client ID.

            iCurrentClientSessionId = aSessionId;

            //Fetch and set current client data.

            iCurrentClientData = iClients[aSessionId];

            //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 tableLayoutPanel.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 tableLayoutPanel.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(tableLayoutPanel.Width, tableLayoutPanel.Height);

            tableLayoutPanel.DrawToBitmap(bmp, tableLayoutPanel.ClientRectangle);

            //Bitmap bmpToSave = new Bitmap(bmp);

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

            ((MarqueeLabel)tableLayoutPanel.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 Display.TMiniDisplayRequest.EMiniDisplayRequestFirmwareRevision:

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

                        //Issue next request then

                        iDisplay.RequestPowerSupplyStatus();

                        break;

                    case Display.TMiniDisplayRequest.EMiniDisplayRequestPowerSupplyStatus:

                        if (iDisplay.PowerSupplyStatus())

                        {

                            toolStripStatusLabelPower.Text = "ON";

                        }

                        else

                        {

                            toolStripStatusLabelPower.Text = "OFF";

                        }

                        //Issue next request then

                        iDisplay.RequestDeviceId();

                        break;

                    case Display.TMiniDisplayRequest.EMiniDisplayRequestDeviceId:

                        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

        private void timer_Tick(object sender, EventArgs e)

        {

            //Update our animations

            DateTime NewTickTime = DateTime.Now;

			UpdateNetworkSignal(LastTickTime, NewTickTime);

            //Update animation for all our marquees

            foreach (Control ctrl in tableLayoutPanel.Controls)

            {

                if (ctrl is MarqueeLabel)

                {

                    ((MarqueeLabel)ctrl).UpdateAnimation(LastTickTime, NewTickTime);

                }

            }

            //Update our display

            if (iDisplay.IsOpen())

            {

                CheckForRequestResults();

                //Draw to bitmap

                if (iCreateBitmap)

                {

                    iBmp = new System.Drawing.Bitmap(tableLayoutPanel.Width, tableLayoutPanel.Height, PixelFormat.Format32bppArgb);

                }

                tableLayoutPanel.DrawToBitmap(iBmp, tableLayoutPanel.ClientRectangle);

                //iBmp.Save("D:\\capture.png");

                //Send it to our display

                for (int i = 0; i < iBmp.Width; i++)

                {

                    for (int j = 0; j < iBmp.Height; j++)

                    {

                        unchecked

                        {

                            //Get our processed pixel coordinates

                            int x = iScreenX(iBmp, i);

                            int y = iScreenY(iBmp, j);

                            //Get pixel color

                            uint color = (uint)iBmp.GetPixel(i, j).ToArgb();

                            //Apply color effects

                            color = iColorFx(x,y,color);

                            //Now set our pixel

                            iDisplay.SetPixel(x, y, color);

                        }

                    }

                }

                iDisplay.SwapBuffers();

            }

            //Compute instant FPS

            toolStripStatusLabelFps.Text = (1.0/NewTickTime.Subtract(LastTickTime).TotalSeconds).ToString("F0") + " / " + (1000/timer.Interval).ToString() + " FPS";

            LastTickTime = NewTickTime;

        }

		/// <summary>

		/// Attempt to establish connection with our display hardware.

		/// </summary>

        private void OpenDisplayConnection()

        {

            CloseDisplayConnection();

            if (!iDisplay.Open((Display.TMiniDisplayType)cds.DisplayType))

            {   

				UpdateStatus();               

				toolStripStatusLabelConnect.Text = "Connection error";

            }

        }

        private void CloseDisplayConnection()

        {

			//Status will be updated upon receiving the closed event

            iDisplay.Close();

        }

        private void buttonOpen_Click(object sender, EventArgs e)

        {

            OpenDisplayConnection();

        }

        private void buttonClose_Click(object sender, EventArgs e)

        {

            CloseDisplayConnection();

        }

        private void buttonClear_Click(object sender, EventArgs e)

        {

            iDisplay.Clear();

            iDisplay.SwapBuffers();

        }

        private void buttonFill_Click(object sender, EventArgs e)

        {

            iDisplay.Fill();

            iDisplay.SwapBuffers();

        }

        private void trackBarBrightness_Scroll(object sender, EventArgs e)

        {

            cds.Brightness = trackBarBrightness.Value;

            Properties.Settings.Default.Save();

            iDisplay.SetBrightness(trackBarBrightness.Value);

        }

        /// <summary>

        /// CDS stands for Current Display Settings

        /// </summary>

        private DisplaySettings cds

        {

            get

            {

                DisplaysSettings settings = Properties.Settings.Default.DisplaysSettings;

                if (settings == null)

                {

                    settings = new DisplaysSettings();

                    settings.Init();

                    Properties.Settings.Default.DisplaysSettings = settings;

                }

                //Make sure all our settings have been created

                while (settings.Displays.Count <= Properties.Settings.Default.CurrentDisplayIndex)

                {

                    settings.Displays.Add(new DisplaySettings());

                }

                DisplaySettings displaySettings = settings.Displays[Properties.Settings.Default.CurrentDisplayIndex];

                return displaySettings;

            }

        }

        /// <summary>

        /// Check if the given font has a fixed character pitch.

        /// </summary>

        /// <param name="ft"></param>

        /// <returns>0.0f if this is not a monospace font, otherwise returns the character width.</returns>

        public float IsFixedWidth(Font ft)

        {

            Graphics g = CreateGraphics();

            char[] charSizes = new char[] { 'i', 'a', 'Z', '%', '#', 'a', 'B', 'l', 'm', ',', '.' };

            float charWidth = g.MeasureString("I", ft, Int32.MaxValue, StringFormat.GenericTypographic).Width;

            bool fixedWidth = true;

            foreach (char c in charSizes)

                if (g.MeasureString(c.ToString(), ft, Int32.MaxValue, StringFormat.GenericTypographic).Width != charWidth)

                    fixedWidth = false;

            if (fixedWidth)

            {

                return charWidth;

            }

            return 0.0f;

        }

		/// <summary>

		/// Synchronize UI with settings

		/// </summary>

        private void UpdateStatus()

        {            

            //Load settings

            checkBoxShowBorders.Checked = cds.ShowBorders;

            tableLayoutPanel.CellBorderStyle = (cds.ShowBorders ? TableLayoutPanelCellBorderStyle.Single : TableLayoutPanelCellBorderStyle.None);

            //Set the proper font to each of our labels

            foreach (MarqueeLabel ctrl in tableLayoutPanel.Controls)

            {

                ctrl.Font = cds.Font;

            }

            CheckFontHeight();

			//Check if "run on Windows startup" is enabled

			checkBoxAutoStart.Checked = iStartupManager.Startup;

			//

            checkBoxConnectOnStartup.Checked = Properties.Settings.Default.DisplayConnectOnStartup;

			checkBoxMinimizeToTray.Checked = Properties.Settings.Default.MinimizeToTray;

			checkBoxStartMinimized.Checked = Properties.Settings.Default.StartMinimized;

            checkBoxReverseScreen.Checked = cds.ReverseScreen;

            checkBoxInverseColors.Checked = cds.InverseColors;

			checkBoxShowVolumeLabel.Checked = cds.ShowVolumeLabel;

            checkBoxScaleToFit.Checked = cds.ScaleToFit;

            maskedTextBoxMinFontSize.Enabled = cds.ScaleToFit;

            labelMinFontSize.Enabled = cds.ScaleToFit;

            maskedTextBoxMinFontSize.Text = cds.MinFontSize.ToString();

			maskedTextBoxScrollingSpeed.Text = cds.ScrollingSpeedInPixelsPerSecond.ToString();

            comboBoxDisplayType.SelectedIndex = cds.DisplayType;

            timer.Interval = cds.TimerInterval;

            maskedTextBoxTimerInterval.Text = cds.TimerInterval.ToString();

            textBoxScrollLoopSeparator.Text = cds.Separator;

            //

            SetupPixelDelegates();

            if (iDisplay.IsOpen())

            {

				//We have a display connection

				//Reflect that in our UI

				tableLayoutPanel.Enabled = true;

				panelDisplay.Enabled = true;

                //Only setup brightness if display is open

                trackBarBrightness.Minimum = iDisplay.MinBrightness();

                trackBarBrightness.Maximum = iDisplay.MaxBrightness();

				if (cds.Brightness < iDisplay.MinBrightness() || cds.Brightness > iDisplay.MaxBrightness())

				{

					//Brightness out of range, this can occur when using auto-detect

					//Use max brightness instead

					trackBarBrightness.Value = iDisplay.MaxBrightness();

					iDisplay.SetBrightness(iDisplay.MaxBrightness());

				}

				else

				{

					trackBarBrightness.Value = cds.Brightness;

					iDisplay.SetBrightness(cds.Brightness);

				}

				//Try compute the steps to something that makes sense

                trackBarBrightness.LargeChange = Math.Max(1, (iDisplay.MaxBrightness() - iDisplay.MinBrightness()) / 5);

                trackBarBrightness.SmallChange = 1;

                //

                buttonFill.Enabled = true;

                buttonClear.Enabled = true;

                buttonOpen.Enabled = false;

                buttonClose.Enabled = true;