//

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

//Network

using NETWORKLIST;

//

using SharpDisplayClient;

using SharpDisplay;

using MiniDisplayInterop;

using SharpLib.Display;

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 MainForm : MainFormHid, 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;

		//

		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 notifcation icon.

        /// </summary>

        private SharpLib.Notification.Control iRecordingNotification;

        /// <summary>

        /// Allow user to receive window messages;

        /// </summary>

        public event WndProcDelegate OnWndProc;

        public MainForm()

        {

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

			//Populate device types

			PopulateDeviceTypes();

            //Populate optical drives

            PopulateOpticalDrives();

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

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

        }

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

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

        {

            //Reset our list of drives

            comboBoxOpticalDrives.Items.Clear();

            comboBoxOpticalDrives.Items.Add("None");

            //Go through each drives on our system and collected the optical ones in our list

            DriveInfo[] allDrives = DriveInfo.GetDrives();

            foreach (DriveInfo d in allDrives)

            {

                Debug.WriteLine("Drive " + d.Name);

                Debug.WriteLine("  Drive type: {0}", d.DriveType);

                if (d.DriveType==DriveType.CDRom)

                {

                    //This is an optical drive, add it now

                    comboBoxOpticalDrives.Items.Add(d.Name.Substring(0,2));

                }                

            }           

        }

        /// <summary>

        /// 

        /// </summary>

        /// <returns></returns>

        public string OpticalDriveToEject()

        {

            return comboBoxOpticalDrives.SelectedItem.ToString();

        }

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

        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 iTableLayoutPanel.Controls)

            {

                if (ctrl is MarqueeLabel)

                {

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

                }

            }

            //Update our display

            if (iDisplay.IsOpen())

            {

                CheckForRequestResults();

				//Check if frame rendering is needed

				//Typically used when showing clock

				if (!iSkipFrameRendering)

				{

					//Draw to bitmap

					if (iCreateBitmap)

					{

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

                        iCreateBitmap = false;

                    }

					iTableLayoutPanel.DrawToBitmap(iBmp, iTableLayoutPanel.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((MiniDisplay.Type)cds.DisplayType))

            {   

				UpdateStatus();               

				toolStripStatusLabelConnect.Text = "Connection error";

            }

        }

        private void CloseDisplayConnection()

        {

			//Status will be updated upon receiving the closed event

			if (iDisplay == null || !iDisplay.IsOpen())

			{

				return;

			}

			//Do not clear if we gave up on rendering already.

			//This means we will keep on displaying clock on MDM166AA for instance.

			if (!iSkipFrameRendering)

			{

				iDisplay.Clear();

				iDisplay.SwapBuffers();

			}