SharpDisplayManager: Server/MainForm.cs@9979787100b1

     1 using System;

     2 using System.Collections.Generic;

     3 using System.ComponentModel;

     4 using System.Data;

     5 using System.Drawing;

     6 using System.Linq;

     7 using System.Text;

     8 using System.Threading.Tasks;

     9 using System.Windows.Forms;

    10 using System.IO;

    11 using CodeProject.Dialog;

    12 using System.Drawing.Imaging;

    13 using System.ServiceModel;

    14 using System.Threading;

    15 using System.Diagnostics;

    16 //

    17 using SharpDisplayClient;

    18 using SharpDisplay;

    20 namespace SharpDisplayManager

    21 {

    22     //Types declarations

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

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

    26     /// <summary>

    27     /// Our Display manager main form

    28     /// </summary>

    29     public partial class MainForm : Form

    30     {

    32         DateTime LastTickTime;

    33         Display iDisplay;

    34         System.Drawing.Bitmap iBmp;

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

    36         ServiceHost iServiceHost;

    37         /// <summary>

    38         /// Our collection of clients

    39         /// </summary>

    40         public Dictionary<string, ClientData> iClients;

    41         public bool iClosing;

    42         ColorProcessingDelegate iColorFx;

    43         CoordinateTranslationDelegate iScreenX;

    44         CoordinateTranslationDelegate iScreenY;

    46         public MainForm()

    47         {

    48             LastTickTime = DateTime.Now;

    49             iDisplay = new Display();

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

    52             InitializeComponent();

    53             UpdateStatus();

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

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

    56             iCreateBitmap = false;

    57             //

    58             //this.tableLayoutPanel.CellPaint += new TableLayoutCellPaintEventHandler(tableLayoutPanel_CellPaint);

    59         }

    61         private void MainForm_Load(object sender, EventArgs e)

    62         {

    63             StartServer();

    65             if (Properties.Settings.Default.DisplayConnectOnStartup)

    66             {

    67                 OpenDisplayConnection();

    68             }

    69         }

    71         //Testing that stuff

    72         private void tableLayoutPanel_CellPaint(object sender, TableLayoutCellPaintEventArgs e)

    73         {

    74             var panel = sender as TableLayoutPanel;

    75             //e.Graphics.SmoothingMode = SmoothingMode.HighQuality;

    76             var rectangle = e.CellBounds;

    77             using (var pen = new Pen(Color.Black, 1))

    78             {

    79                 pen.Alignment = System.Drawing.Drawing2D.PenAlignment.Center;

    80                 pen.DashStyle = System.Drawing.Drawing2D.DashStyle.Solid;

    82                 if (e.Row == (panel.RowCount - 1))

    83                 {

    84                     rectangle.Height -= 1;

    85                 }

    87                 if (e.Column == (panel.ColumnCount - 1))

    88                 {

    89                     rectangle.Width -= 1;

    90                 }

    92                 e.Graphics.DrawRectangle(pen, rectangle);

    93             }

    94         }

    97         private void buttonFont_Click(object sender, EventArgs e)

    98         {

    99             //fontDialog.ShowColor = true;

   100             //fontDialog.ShowApply = true;

   101             fontDialog.ShowEffects = true;

   102             fontDialog.Font = marqueeLabelTop.Font;

   104             fontDialog.FixedPitchOnly = checkBoxFixedPitchFontOnly.Checked;

   106             //fontDialog.ShowHelp = true;

   108             //fontDlg.MaxSize = 40;

   109             //fontDlg.MinSize = 22;

   111             //fontDialog.Parent = this;

   112             //fontDialog.StartPosition = FormStartPosition.CenterParent;

   114             //DlgBox.ShowDialog(fontDialog);

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

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

   118             {

   120                 //MsgBox.Show("MessageBox MsgBox", "MsgBox caption");

   122                 //MessageBox.Show("Ok");

   123                 marqueeLabelTop.Font = fontDialog.Font;

   124                 marqueeLabelBottom.Font = fontDialog.Font;

   125                 cds.Font = fontDialog.Font;

   126                 Properties.Settings.Default.Save();

   127                 //

   128                 CheckFontHeight();

   129             }

   130         }

   132         /// <summary>

   133         ///

   134         /// </summary>

   135         void CheckFontHeight()

   136         {

   137             //Show font height and width

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

   139             float charWidth = IsFixedWidth(cds.Font);

   140             if (charWidth == 0.0f)

   141             {

   142                 labelFontWidth.Visible = false;

   143             }

   144             else

   145             {

   146                 labelFontWidth.Visible = true;

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

   148             }

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

   151             if (marqueeLabelBottom.Font.Height > marqueeLabelBottom.Height)

   152             {

   153                 labelWarning.Text = "WARNING: Selected font is too height by " + (marqueeLabelBottom.Font.Height - marqueeLabelBottom.Height) + " pixels!";

   154                 labelWarning.Visible = true;

   155             }

   156             else

   157             {

   158                 labelWarning.Visible = false;

   159             }

   161         }

   163         private void buttonCapture_Click(object sender, EventArgs e)

   164         {

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

   166             tableLayoutPanel.DrawToBitmap(bmp, tableLayoutPanel.ClientRectangle);

   167             //Bitmap bmpToSave = new Bitmap(bmp);

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

   170             marqueeLabelTop.Text = "Sweet";

   172             /*

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

   174             using (MemoryStream memory = new MemoryStream())

   175             {

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

   177                 {

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

   179                     byte[] bytes = memory.ToArray();

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

   181                 }

   182             }

   183              */

   185         }

   187         private void CheckForRequestResults()

   188         {

   189             if (iDisplay.IsRequestPending())

   190             {

   191                 switch (iDisplay.AttemptRequestCompletion())

   192                 {

   193                     case Display.TMiniDisplayRequest.EMiniDisplayRequestFirmwareRevision:

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

   195                         //Issue next request then

   196                         iDisplay.RequestPowerSupplyStatus();

   197                         break;

   199                     case Display.TMiniDisplayRequest.EMiniDisplayRequestPowerSupplyStatus:

   200                         if (iDisplay.PowerSupplyStatus())

   201                         {

   202                             toolStripStatusLabelPower.Text = "ON";

   203                         }

   204                         else

   205                         {

   206                             toolStripStatusLabelPower.Text = "OFF";

   207                         }

   208                         //Issue next request then

   209                         iDisplay.RequestDeviceId();

   210                         break;

   212                     case Display.TMiniDisplayRequest.EMiniDisplayRequestDeviceId:

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

   214                         //No more request to issue

   215                         break;

   216                 }

   217             }

   218         }

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

   221         {

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

   223             {

   224                 return 0xFFFFFFFF;

   225             }

   226             return 0x00000000;

   227         }

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

   230         {

   231             return aPixel;

   232         }

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

   235         {

   236             return ~aPixel;

   237         }

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

   240         {

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

   242             {

   243                 return ~aPixel;

   244             }

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

   246             {

   247                 return ~aPixel;

   248             }

   249             return 0x00000000;

   250         }

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

   254         {

   255             return aBmp.Width - aX - 1;

   256         }

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

   259         {

   260             return iBmp.Height - aY - 1;

   261         }

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

   264         {

   265             return aX;

   266         }

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

   269         {

   270             return aY;

   271         }

   273         /// <summary>

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

   275         /// </summary>

   276         private void SetupPixelDelegates()

   277         {

   278             //Select our pixel processing routine

   279             if (cds.InverseColors)

   280             {

   281                 //iColorFx = ColorChessboard;

   282                 iColorFx = ColorInversed;

   283             }

   284             else

   285             {

   286                 iColorFx = ColorWhiteIsOn;

   287             }

   289             //Select proper coordinate translation functions

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

   291             if (cds.ReverseScreen)

   292             {

   293                 iScreenX = ScreenReversedX;

   294                 iScreenY = ScreenReversedY;

   295             }

   296             else

   297             {

   298                 iScreenX = ScreenX;

   299                 iScreenY = ScreenY;

   300             }

   302         }

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

   305         private void timer_Tick(object sender, EventArgs e)

   306         {

   307             //Update our animations

   308             DateTime NewTickTime = DateTime.Now;

   310             marqueeLabelTop.UpdateAnimation(LastTickTime, NewTickTime);

   311             marqueeLabelBottom.UpdateAnimation(LastTickTime, NewTickTime);

   313             //Update our display

   314             if (iDisplay.IsOpen())

   315             {

   316                 CheckForRequestResults();

   318                 //Draw to bitmap

   319                 if (iCreateBitmap)

   320                 {

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

   322                 }

   323                 tableLayoutPanel.DrawToBitmap(iBmp, tableLayoutPanel.ClientRectangle);

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

   326                 //Send it to our display

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

   328                 {

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

   330                     {

   331                         unchecked

   332                         {

   333                             //Get our processed pixel coordinates

   334                             int x = iScreenX(iBmp, i);

   335                             int y = iScreenY(iBmp, j);

   336                             //Get pixel color

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

   338                             //Apply color effects

   339                             color = iColorFx(x,y,color);

   340                             //Now set our pixel

   341                             iDisplay.SetPixel(x, y, color);

   342                         }

   343                     }

   344                 }

   346                 iDisplay.SwapBuffers();

   348             }

   350             //Compute instant FPS

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

   353             LastTickTime = NewTickTime;

   355         }

   357         private void OpenDisplayConnection()

   358         {

   359             CloseDisplayConnection();

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

   362             {

   363                 UpdateStatus();

   364                 iDisplay.RequestFirmwareRevision();

   365             }

   366             else

   367             {

   368                 UpdateStatus();

   369                 toolStripStatusLabelConnect.Text = "Connection error";

   370             }

   371         }

   373         private void CloseDisplayConnection()

   374         {

   375             iDisplay.Close();

   376             UpdateStatus();

   377         }

   379         private void buttonOpen_Click(object sender, EventArgs e)

   380         {

   381             OpenDisplayConnection();

   382         }

   384         private void buttonClose_Click(object sender, EventArgs e)

   385         {

   386             CloseDisplayConnection();

   387         }

   389         private void buttonClear_Click(object sender, EventArgs e)

   390         {

   391             iDisplay.Clear();

   392             iDisplay.SwapBuffers();

   393         }

   395         private void buttonFill_Click(object sender, EventArgs e)

   396         {

   397             iDisplay.Fill();

   398             iDisplay.SwapBuffers();

   399         }

   401         private void trackBarBrightness_Scroll(object sender, EventArgs e)

   402         {

   403             cds.Brightness = trackBarBrightness.Value;

   404             Properties.Settings.Default.Save();

   405             iDisplay.SetBrightness(trackBarBrightness.Value);

   407         }

   410         /// <summary>

   411         /// CDS stands for Current Display Settings

   412         /// </summary>

   413         private DisplaySettings cds

   414         {

   415             get

   416             {

   417                 DisplaysSettings settings = Properties.Settings.Default.DisplaySettings;

   418                 if (settings == null)

   419                 {

   420                     settings = new DisplaysSettings();

   421                     settings.Init();

   422                     Properties.Settings.Default.DisplaySettings = settings;

   423                 }

   425                 //Make sure all our settings have been created

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

   427                 {

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

   429                 }

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

   432                 return displaySettings;

   433             }

   434         }

   436         /// <summary>

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

   438         /// </summary>

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

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

   441         public float IsFixedWidth(Font ft)

   442         {

   443             Graphics g = CreateGraphics();

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

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

   447             bool fixedWidth = true;

   449             foreach (char c in charSizes)

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

   451                     fixedWidth = false;

   453             if (fixedWidth)

   454             {

   455                 return charWidth;

   456             }

   458             return 0.0f;

   459         }

   461         private void UpdateStatus()

   462         {

   463             //Synchronize UI with settings

   464             //Load settings

   465             checkBoxShowBorders.Checked = cds.ShowBorders;

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

   467             marqueeLabelTop.Font = cds.Font;

   468             marqueeLabelBottom.Font = cds.Font;

   469             CheckFontHeight();

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

   471             checkBoxReverseScreen.Checked = cds.ReverseScreen;

   472             checkBoxInverseColors.Checked = cds.InverseColors;

   473             comboBoxDisplayType.SelectedIndex = cds.DisplayType;

   474             timer.Interval = cds.TimerInterval;

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

   476             //

   477             SetupPixelDelegates();

   479             if (iDisplay.IsOpen())

   480             {

   481                 //Only setup brightness if display is open

   482                 trackBarBrightness.Minimum = iDisplay.MinBrightness();

   483                 trackBarBrightness.Maximum = iDisplay.MaxBrightness();

   484                 trackBarBrightness.Value = cds.Brightness;

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

   486                 trackBarBrightness.SmallChange = 1;

   487                 iDisplay.SetBrightness(cds.Brightness);

   488                 //

   489                 buttonFill.Enabled = true;

   490                 buttonClear.Enabled = true;

   491                 buttonOpen.Enabled = false;

   492                 buttonClose.Enabled = true;

   493                 trackBarBrightness.Enabled = true;

   494                 toolStripStatusLabelConnect.Text = "Connected - " + iDisplay.Vendor() + " - " + iDisplay.Product();

   495                 //+ " - " + iDisplay.SerialNumber();

   497                 if (iDisplay.SupportPowerOnOff())

   498                 {

   499                     buttonPowerOn.Enabled = true;

   500                     buttonPowerOff.Enabled = true;

   501                 }

   502                 else

   503                 {

   504                     buttonPowerOn.Enabled = false;

   505                     buttonPowerOff.Enabled = false;

   506                 }

   508                 if (iDisplay.SupportClock())

   509                 {

   510                     buttonShowClock.Enabled = true;

   511                     buttonHideClock.Enabled = true;

   512                 }

   513                 else

   514                 {

   515                     buttonShowClock.Enabled = false;

   516                     buttonHideClock.Enabled = false;

   517                 }

   518             }

   519             else

   520             {

   521                 buttonFill.Enabled = false;

   522                 buttonClear.Enabled = false;

   523                 buttonOpen.Enabled = true;

   524                 buttonClose.Enabled = false;

   525                 trackBarBrightness.Enabled = false;

   526                 buttonPowerOn.Enabled = false;

   527                 buttonPowerOff.Enabled = false;

   528                 buttonShowClock.Enabled = false;

   529                 buttonHideClock.Enabled = false;

   530                 toolStripStatusLabelConnect.Text = "Disconnected";

   531                 toolStripStatusLabelPower.Text = "N/A";

   532             }

   533         }

   537         private void checkBoxShowBorders_CheckedChanged(object sender, EventArgs e)

   538         {

   539             //Save our show borders setting

   540             tableLayoutPanel.CellBorderStyle = (checkBoxShowBorders.Checked ? TableLayoutPanelCellBorderStyle.Single : TableLayoutPanelCellBorderStyle.None);

   541             cds.ShowBorders = checkBoxShowBorders.Checked;

   542             Properties.Settings.Default.Save();

   543             CheckFontHeight();

   544         }

   546         private void checkBoxConnectOnStartup_CheckedChanged(object sender, EventArgs e)

   547         {

   548             //Save our connect on startup setting

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

   550             Properties.Settings.Default.Save();

   551         }

   553         private void checkBoxReverseScreen_CheckedChanged(object sender, EventArgs e)

   554         {

   555             //Save our reverse screen setting

   556             cds.ReverseScreen = checkBoxReverseScreen.Checked;

   557             Properties.Settings.Default.Save();

   558             SetupPixelDelegates();

   559         }

   561         private void checkBoxInverseColors_CheckedChanged(object sender, EventArgs e)

   562         {

   563             //Save our inverse colors setting

   564             cds.InverseColors = checkBoxInverseColors.Checked;

   565             Properties.Settings.Default.Save();

   566             SetupPixelDelegates();

   567         }

   569         private void MainForm_Resize(object sender, EventArgs e)

   570         {

   571             if (WindowState == FormWindowState.Minimized)

   572             {

   573                 // Do some stuff

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

   575                 iCreateBitmap = true;

   576             }

   577         }

   579         private void MainForm_FormClosing(object sender, FormClosingEventArgs e)

   580         {

   581             StopServer();

   582             e.Cancel = iClosing;

   583         }

   585         public void StartServer()

   586         {

   587             iServiceHost = new ServiceHost

   588                 (

   589                     typeof(Session),

   590                     new Uri[] { new Uri("net.tcp://localhost:8001/") }

   591                 );

   593             iServiceHost.AddServiceEndpoint(typeof(IService), new NetTcpBinding(SecurityMode.None, true), "DisplayService");

   594             iServiceHost.Open();

   595         }

   597         public void StopServer()

   598         {

   599             if (iClients.Count > 0 && !iClosing)

   600             {

   601                 //Tell our clients

   602                 iClosing = true;

   603                 BroadcastCloseEvent();

   604             }

   605             else if (iClosing)

   606             {

   607                 if (MessageBox.Show("Force exit?", "Waiting for clients...", MessageBoxButtons.YesNo, MessageBoxIcon.Warning) == DialogResult.Yes)

   608                 {

   609                     iClosing = false; //We make sure we force close if asked twice

   610                 }

   611             }

   612             else

   613             {

   614                 //We removed that as it often lags for some reason

   615                 //iServiceHost.Close();

   616             }

   617         }

   619         public void BroadcastCloseEvent()

   620         {

   621             Trace.TraceInformation("BroadcastCloseEvent - start");

   623             var inactiveClients = new List<string>();

   624             foreach (var client in iClients)

   625             {

   626                 //if (client.Key != eventData.ClientName)

   627                 {

   628                     try

   629                     {

   630                         Trace.TraceInformation("BroadcastCloseEvent - " + client.Key);

   631                         client.Value.Callback.OnCloseOrder(/*eventData*/);

   632                     }

   633                     catch (Exception ex)

   634                     {

   635                         inactiveClients.Add(client.Key);

   636                     }

   637                 }

   638             }

   640             if (inactiveClients.Count > 0)

   641             {

   642                 foreach (var client in inactiveClients)

   643                 {

   644                     iClients.Remove(client);

   645                     Program.iMainForm.treeViewClients.Nodes.Remove(Program.iMainForm.treeViewClients.Nodes.Find(client, false)[0]);

   646                 }

   647             }

   648         }

   650         private void buttonStartClient_Click(object sender, EventArgs e)

   651         {

   652             Thread clientThread = new Thread(SharpDisplayClient.Program.Main);

   653             clientThread.Start();

   654             BringToFront();

   655         }

   657         private void buttonSuspend_Click(object sender, EventArgs e)

   658         {

   659             LastTickTime = DateTime.Now; //Reset timer to prevent jump

   660             timer.Enabled = !timer.Enabled;

   661             if (!timer.Enabled)

   662             {

   663                 buttonSuspend.Text = "Run";

   664             }

   665             else

   666             {

   667                 buttonSuspend.Text = "Pause";

   668             }

   669         }

   671         private void buttonCloseClients_Click(object sender, EventArgs e)

   672         {

   673             BroadcastCloseEvent();

   674         }

   676         private void treeViewClients_AfterSelect(object sender, TreeViewEventArgs e)

   677         {

   679         }

   681         //Delegates are used for our thread safe method

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

   683         public delegate void RemoveClientDelegate(string aSessionId);

   684         public delegate void SetTextDelegate(string SessionId, TextField aTextField);

   685         public delegate void SetTextsDelegate(string SessionId, System.Collections.Generic.IList<TextField> aTextFields);

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

   689         /// <summary>

   690         ///

   691         /// </summary>

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

   693         /// <param name="aCallback"></param>

   694         public void AddClientThreadSafe(string aSessionId, ICallback aCallback)

   695         {

   696             if (this.InvokeRequired)

   697             {

   698                 //Not in the proper thread, invoke ourselves

   699                 AddClientDelegate d = new AddClientDelegate(AddClientThreadSafe);

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

   701             }

   702             else

   703             {

   704                 //We are in the proper thread

   705                 //Add this session to our collection of clients

   706                 ClientData newClient = new ClientData(aSessionId, aCallback);

   707                 Program.iMainForm.iClients.Add(aSessionId, newClient);

   708                 //Add this session to our UI

   709                 UpdateClientTreeViewNode(newClient);

   710             }

   711         }

   713         /// <summary>

   714         ///

   715         /// </summary>

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

   717         public void RemoveClientThreadSafe(string aSessionId)

   718         {

   719             if (this.InvokeRequired)

   720             {

   721                 //Not in the proper thread, invoke ourselves

   722                 RemoveClientDelegate d = new RemoveClientDelegate(RemoveClientThreadSafe);

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

   724             }

   725             else

   726             {

   727                 //We are in the proper thread

   728                 //Remove this session from both client collection and UI tree view

   729                 if (Program.iMainForm.iClients.Keys.Contains(aSessionId))

   730                 {

   731                     Program.iMainForm.iClients.Remove(aSessionId);

   732                     Program.iMainForm.treeViewClients.Nodes.Remove(Program.iMainForm.treeViewClients.Nodes.Find(aSessionId, false)[0]);

   733                 }

   735                 if (iClosing && iClients.Count == 0)

   736                 {

   737                     //We were closing our form

   738                     //All clients are now closed

   739                     //Just resume our close operation

   740                     iClosing = false;

   741                     Close();

   742                 }

   743             }

   744         }

   746         /// <summary>

   747         ///

   748         /// </summary>

   749         /// <param name="aLineIndex"></param>

   750         /// <param name="aText"></param>

   751         public void SetTextThreadSafe(string aSessionId, TextField aTextField)

   752         {

   753             if (this.InvokeRequired)

   754             {

   755                 //Not in the proper thread, invoke ourselves

   756                 SetTextDelegate d = new SetTextDelegate(SetTextThreadSafe);

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

   758             }

   759             else

   760             {

   761                 ClientData client = iClients[aSessionId];

   762                 if (client != null)

   763                 {

   764                     //Make sure all our texts are in place

   765                     while (client.Texts.Count < (aTextField.Index + 1))

   766                     {

   767                         //Add a text field with proper index

   768                         client.Texts.Add(new TextField(client.Texts.Count));

   769                     }

   770                     client.Texts[aTextField.Index] = aTextField;

   772                     //We are in the proper thread

   773                     //Only support two lines for now

   774                     if (aTextField.Index == 0)

   775                     {

   776                         marqueeLabelTop.Text = aTextField.Text;

   777                         marqueeLabelTop.TextAlign = aTextField.Alignment;

   778                     }

   779                     else if (aTextField.Index == 1)

   780                     {

   781                         marqueeLabelBottom.Text = aTextField.Text;

   782                         marqueeLabelBottom.TextAlign = aTextField.Alignment;

   783                     }

   786                     UpdateClientTreeViewNode(client);

   787                 }

   788             }

   789         }

   791         /// <summary>

   792         ///

   793         /// </summary>

   794         /// <param name="aTexts"></param>

   795         public void SetTextsThreadSafe(string aSessionId, System.Collections.Generic.IList<TextField> aTextFields)

   796         {

   797             if (this.InvokeRequired)

   798             {

   799                 //Not in the proper thread, invoke ourselves

   800                 SetTextsDelegate d = new SetTextsDelegate(SetTextsThreadSafe);

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

   802             }

   803             else

   804             {

   805                 //We are in the proper thread

   806                 ClientData client = iClients[aSessionId];

   807                 if (client != null)

   808                 {

   809                     //Populate our client with the given text fields

   810                     int j = 0;

   811                     foreach (TextField textField in aTextFields)

   812                     {

   813                         if (client.Texts.Count < (j + 1))

   814                         {

   815                             client.Texts.Add(textField);

   816                         }

   817                         else

   818                         {

   819                             client.Texts[j] = textField;

   820                         }

   821                         j++;

   822                     }

   823                     //Only support two lines for now

   824                     for (int i = 0; i < aTextFields.Count; i++)

   825                     {

   826                         if (aTextFields[i].Index == 0)

   827                         {

   828                             marqueeLabelTop.Text = aTextFields[i].Text;

   829                             marqueeLabelTop.TextAlign = aTextFields[i].Alignment;

   830                         }

   831                         else if (aTextFields[i].Index == 1)

   832                         {

   833                             marqueeLabelBottom.Text = aTextFields[i].Text;

   834                             marqueeLabelBottom.TextAlign = aTextFields[i].Alignment;

   835                         }

   836                     }

   839                     UpdateClientTreeViewNode(client);

   840                 }

   841             }

   842         }

   845         /// <summary>

   846         ///

   847         /// </summary>

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

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

   850         public void SetClientNameThreadSafe(string aSessionId, string aName)

   851         {

   852             if (this.InvokeRequired)

   853             {

   854                 //Not in the proper thread, invoke ourselves

   855                 SetClientNameDelegate d = new SetClientNameDelegate(SetClientNameThreadSafe);

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

   857             }

   858             else

   859             {

   860                 //We are in the proper thread

   861                 //Get our client

   862                 ClientData client = iClients[aSessionId];

   863                 if (client != null)

   864                 {

   865                     //Set its name

   866                     client.Name = aName;

   867                     //Update our tree-view

   868                     UpdateClientTreeViewNode(client);

   869                 }

   870             }

   871         }

   873         /// <summary>

   874         ///

   875         /// </summary>

   876         /// <param name="aClient"></param>

   877         private void UpdateClientTreeViewNode(ClientData aClient)

   878         {

   879             if (aClient == null)

   880             {

   881                 return;

   882             }

   884             TreeNode node = null;

   885             //Check that our client node already exists

   886             //Get our client root node using its key which is our session ID

   887             TreeNode[] nodes = treeViewClients.Nodes.Find(aClient.SessionId, false);

   888             if (nodes.Count()>0)

   889             {

   890                 //We already have a node for that client

   891                 node = nodes[0];

   892                 //Clear children as we are going to recreate them below

   893                 node.Nodes.Clear();

   894             }

   895             else

   896             {

   897                 //Client node does not exists create a new one

   898                 treeViewClients.Nodes.Add(aClient.SessionId, aClient.SessionId);

   899                 node = treeViewClients.Nodes.Find(aClient.SessionId, false)[0];

   900             }

   902             if (node != null)

   903             {

   904                 //Change its name

   905                 if (aClient.Name != "")

   906                 {

   907                     //We have a name, us it as text for our root node

   908                     node.Text = aClient.Name;

   909                     //Add a child with SessionId

   910                     node.Nodes.Add(new TreeNode(aClient.SessionId));

   911                 }

   912                 else

   913                 {

   914                     //No name, use session ID instead

   915                     node.Text = aClient.SessionId;

   916                 }

   918                 if (aClient.Texts.Count > 0)

   919                 {

   920                     //Create root node for our texts

   921                     TreeNode textsRoot = new TreeNode("Text");

   922                     node.Nodes.Add(textsRoot);

   923                     //For each text add a new entry

   924                     foreach (TextField field in aClient.Texts)

   925                     {

   926                         textsRoot.Nodes.Add(new TreeNode(field.Text));

   927                     }

   928                 }

   930                 node.ExpandAll();

   931             }

   932         }

   934         private void buttonAddRow_Click(object sender, EventArgs e)

   935         {

   936             if (tableLayoutPanel.RowCount < 6)

   937             {

   938                 tableLayoutPanel.RowCount++;

   939                 CheckFontHeight();

   940             }

   941         }

   943         private void buttonRemoveRow_Click(object sender, EventArgs e)

   944         {

   945             if (tableLayoutPanel.RowCount > 1)

   946             {

   947                 tableLayoutPanel.RowCount--;

   948                 CheckFontHeight();

   949             }

   950         }

   952         private void buttonAddColumn_Click(object sender, EventArgs e)

   953         {

   954             if (tableLayoutPanel.ColumnCount < 8)

   955             {

   956                 tableLayoutPanel.ColumnCount++;

   957                 //CheckFontHeight();

   958             }

   959         }

   961         private void buttonRemoveColumn_Click(object sender, EventArgs e)

   962         {

   963             if (tableLayoutPanel.ColumnCount > 1)

   964             {

   965                 tableLayoutPanel.ColumnCount--;

   966                 //CheckFontHeight();

   967             }

   968         }

   970         private void buttonAlignLeft_Click(object sender, EventArgs e)

   971         {

   972             marqueeLabelTop.TextAlign = ContentAlignment.MiddleLeft;

   973             marqueeLabelBottom.TextAlign = ContentAlignment.MiddleLeft;

   974         }

   976         private void buttonAlignCenter_Click(object sender, EventArgs e)

   977         {

   978             marqueeLabelTop.TextAlign = ContentAlignment.MiddleCenter;

   979             marqueeLabelBottom.TextAlign = ContentAlignment.MiddleCenter;

   980         }

   982         private void buttonAlignRight_Click(object sender, EventArgs e)

   983         {

   984             marqueeLabelTop.TextAlign = ContentAlignment.MiddleRight;

   985             marqueeLabelBottom.TextAlign = ContentAlignment.MiddleRight;

   986         }

   988         private void comboBoxDisplayType_SelectedIndexChanged(object sender, EventArgs e)

   989         {

   990             Properties.Settings.Default.CurrentDisplayIndex = comboBoxDisplayType.SelectedIndex;

   991             cds.DisplayType = comboBoxDisplayType.SelectedIndex;

   992             Properties.Settings.Default.Save();

   993             if (iDisplay.IsOpen())

   994             {

   995                 OpenDisplayConnection();

   996             }

   997             else

   998             {

   999                 UpdateStatus();

  1000             }

  1001         }

  1004         private void maskedTextBoxTimerInterval_TextChanged(object sender, EventArgs e)

  1005         {

  1006             if (maskedTextBoxTimerInterval.Text != "")

  1007             {

  1008                 int interval = Convert.ToInt32(maskedTextBoxTimerInterval.Text);

  1010                 if (interval > 0)

  1011                 {

  1012                     timer.Interval = interval;

  1013                     cds.TimerInterval = timer.Interval;

  1014                     Properties.Settings.Default.Save();

  1015                 }

  1016             }

  1017         }

  1019         private void buttonPowerOn_Click(object sender, EventArgs e)

  1020         {

  1021             iDisplay.PowerOn();

  1022         }

  1024         private void buttonPowerOff_Click(object sender, EventArgs e)

  1025         {

  1026             iDisplay.PowerOff();

  1027         }

  1029         private void buttonShowClock_Click(object sender, EventArgs e)

  1030         {

  1031             iDisplay.ShowClock();

  1032         }

  1034         private void buttonHideClock_Click(object sender, EventArgs e)

  1035         {

  1036             iDisplay.HideClock();

  1037         }

  1039     }

  1041     /// <summary>

  1042     /// A UI thread copy of a client relevant data.

  1043     /// Keeping this copy in the UI thread helps us deal with threading issues.

  1044     /// </summary>

  1045     public class ClientData

  1046     {

  1047         public ClientData(string aSessionId, ICallback aCallback)

  1048         {

  1049             SessionId = aSessionId;

  1050             Name = "";

  1051             Texts = new List<TextField>();

  1052             Callback = aCallback;

  1053         }

  1055         public string SessionId { get; set; }

  1056         public string Name { get; set; }

  1057         public List<TextField> Texts { get; set; }

  1058         public ICallback Callback { get; set; }

  1059     }

  1060 }

author	sl
	Mon, 22 Sep 2014 10:05:45 +0200
changeset 59	9979787100b1
parent 58	2a527027024d
child 60	4f2a73683adc
permissions	-rw-r--r--