SharpDisplayManager: Server/MainForm.cs@fdda7642776a

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

    18 using SharpDisplayClient;

    21 namespace SharpDisplayManager

    22 {

    23     public partial class MainForm : Form

    24     {

    25         DateTime LastTickTime;

    26         Display iDisplay;

    27         System.Drawing.Bitmap iBmp;

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

    29         ServiceHost iServiceHost;

    30         /// <summary>

    31         /// Our collection of clients

    32         /// </summary>

    33         public Dictionary<string, ClientData> iClients;

    34         public bool iClosing;

    36         public MainForm()

    37         {

    38             LastTickTime = DateTime.Now;

    39             iDisplay = new Display();

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

    42             InitializeComponent();

    43             UpdateStatus();

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

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

    46             iCreateBitmap = false;

    47         }

    49         private void MainForm_Load(object sender, EventArgs e)

    50         {

    51             StartServer();

    53             if (Properties.Settings.Default.DisplayConnectOnStartup)

    54             {

    55                 OpenDisplayConnection();

    56             }

    57         }

    60         private void buttonFont_Click(object sender, EventArgs e)

    61         {

    62             //fontDialog.ShowColor = true;

    63             //fontDialog.ShowApply = true;

    64             fontDialog.ShowEffects = true;

    65             fontDialog.Font = marqueeLabelTop.Font;

    67             fontDialog.FixedPitchOnly = checkBoxFixedPitchFontOnly.Checked;

    69             //fontDialog.ShowHelp = true;

    71             //fontDlg.MaxSize = 40;

    72             //fontDlg.MinSize = 22;

    74             //fontDialog.Parent = this;

    75             //fontDialog.StartPosition = FormStartPosition.CenterParent;

    77             //DlgBox.ShowDialog(fontDialog);

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

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

    81             {

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

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

    86                 marqueeLabelTop.Font = fontDialog.Font;

    87                 marqueeLabelBottom.Font = fontDialog.Font;

    88                 cds.Font = fontDialog.Font;

    89                 Properties.Settings.Default.Save();

    90                 //

    91                 CheckFontHeight();

    92             }

    93         }

    95         /// <summary>

    96         ///

    97         /// </summary>

    98         void CheckFontHeight()

    99         {

   100             //Show font height and width

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

   102             float charWidth = IsFixedWidth(cds.Font);

   103             if (charWidth == 0.0f)

   104             {

   105                 labelFontWidth.Visible = false;

   106             }

   107             else

   108             {

   109                 labelFontWidth.Visible = true;

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

   111             }

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

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

   115             {

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

   117                 labelWarning.Visible = true;

   118             }

   119             else

   120             {

   121                 labelWarning.Visible = false;

   122             }

   124         }

   126         private void buttonCapture_Click(object sender, EventArgs e)

   127         {

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

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

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

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

   133             marqueeLabelTop.Text = "Sweet";

   135             /*

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

   137             using (MemoryStream memory = new MemoryStream())

   138             {

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

   140                 {

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

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

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

   144                 }

   145             }

   146              */

   148         }

   150         private void CheckForRequestResults()

   151         {

   152             if (iDisplay.IsRequestPending())

   153             {

   154                 switch (iDisplay.AttemptRequestCompletion())

   155                 {

   156                     case Display.TMiniDisplayRequest.EMiniDisplayRequestFirmwareRevision:

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

   158                         //Issue next request then

   159                         iDisplay.RequestPowerSupplyStatus();

   160                         break;

   162                     case Display.TMiniDisplayRequest.EMiniDisplayRequestPowerSupplyStatus:

   163                         if (iDisplay.PowerSupplyStatus())

   164                         {

   165                             toolStripStatusLabelPower.Text = "ON";

   166                         }

   167                         else

   168                         {

   169                             toolStripStatusLabelPower.Text = "OFF";

   170                         }

   171                         //Issue next request then

   172                         iDisplay.RequestDeviceId();

   173                         break;

   175                     case Display.TMiniDisplayRequest.EMiniDisplayRequestDeviceId:

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

   177                         //No more request to issue

   178                         break;

   179                 }

   180             }

   181         }

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

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

   188         {

   189             return aBmp.Width - aX - 1;

   190         }

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

   193         {

   194             return iBmp.Height - aY - 1;

   195         }

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

   198         {

   199             return aX;

   200         }

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

   203         {

   204             return aY;

   205         }

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

   209         private void timer_Tick(object sender, EventArgs e)

   210         {

   211             //Update our animations

   212             DateTime NewTickTime = DateTime.Now;

   214             marqueeLabelTop.UpdateAnimation(LastTickTime, NewTickTime);

   215             marqueeLabelBottom.UpdateAnimation(LastTickTime, NewTickTime);

   217             //Update our display

   218             if (iDisplay.IsOpen())

   219             {

   220                 CheckForRequestResults();

   222                 //Draw to bitmap

   223                 if (iCreateBitmap)

   224                 {

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

   226                 }

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

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

   230                 //Select proper coordinate translation functions

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

   232                 CoordinateTranslationDelegate screenX;

   233                 CoordinateTranslationDelegate screenY;

   235                 if (cds.ReverseScreen)

   236                 {

   237                     screenX = ScreenReversedX;

   238                     screenY = ScreenReversedY;

   239                 }

   240                 else

   241                 {

   242                     screenX = ScreenX;

   243                     screenY = ScreenY;

   244                 }

   246                 //Send it to our display

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

   248                 {

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

   250                     {

   251                         unchecked

   252                         {

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

   254                             //For some reason when the app is minimized in the task bar only the alpha of our color is set.

   255                             //Thus that strange test for rendering to work both when the app is in the task bar and when it isn't.

   256                             iDisplay.SetPixel(screenX(iBmp, i), screenY(iBmp, j), Convert.ToInt32(!(color != 0xFF000000)));

   257                         }

   258                     }

   259                 }

   261                 iDisplay.SwapBuffers();

   263             }

   265             //Compute instant FPS

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

   268             LastTickTime = NewTickTime;

   270         }

   272         private void OpenDisplayConnection()

   273         {

   274             CloseDisplayConnection();

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

   277             {

   278                 UpdateStatus();

   279                 iDisplay.RequestFirmwareRevision();

   280             }

   281             else

   282             {

   283                 UpdateStatus();

   284                 toolStripStatusLabelConnect.Text = "Connection error";

   285             }

   286         }

   288         private void CloseDisplayConnection()

   289         {

   290             iDisplay.Close();

   291             UpdateStatus();

   292         }

   294         private void buttonOpen_Click(object sender, EventArgs e)

   295         {

   296             OpenDisplayConnection();

   297         }

   299         private void buttonClose_Click(object sender, EventArgs e)

   300         {

   301             CloseDisplayConnection();

   302         }

   304         private void buttonClear_Click(object sender, EventArgs e)

   305         {

   306             iDisplay.Clear();

   307             iDisplay.SwapBuffers();

   308         }

   310         private void buttonFill_Click(object sender, EventArgs e)

   311         {

   312             iDisplay.Fill();

   313             iDisplay.SwapBuffers();

   314         }

   316         private void trackBarBrightness_Scroll(object sender, EventArgs e)

   317         {

   318             cds.Brightness = trackBarBrightness.Value;

   319             Properties.Settings.Default.Save();

   320             iDisplay.SetBrightness(trackBarBrightness.Value);

   322         }

   325         /// <summary>

   326         /// CDS stands for Current Display Settings

   327         /// </summary>

   328         private DisplaySettings cds

   329         {

   330             get

   331             {

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

   333                 if (settings == null)

   334                 {

   335                     settings = new DisplaysSettings();

   336                     settings.Init();

   337                     Properties.Settings.Default.DisplaySettings = settings;

   338                 }

   340                 //Make sure all our settings have been created

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

   342                 {

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

   344                 }

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

   347                 return displaySettings;

   348             }

   349         }

   351         /// <summary>

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

   353         /// </summary>

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

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

   356         public float IsFixedWidth(Font ft)

   357         {

   358             Graphics g = CreateGraphics();

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

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

   362             bool fixedWidth = true;

   364             foreach (char c in charSizes)

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

   366                     fixedWidth = false;

   368             if (fixedWidth)

   369             {

   370                 return charWidth;

   371             }

   373             return 0.0f;

   374         }

   376         private void UpdateStatus()

   377         {

   378             //Synchronize UI with settings

   379             //Load settings

   381             checkBoxShowBorders.Checked = cds.ShowBorders;

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

   383             marqueeLabelTop.Font = cds.Font;

   384             marqueeLabelBottom.Font = cds.Font;

   385             CheckFontHeight();

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

   387             checkBoxReverseScreen.Checked = cds.ReverseScreen;

   388             comboBoxDisplayType.SelectedIndex = cds.DisplayType;

   389             timer.Interval = cds.TimerInterval;

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

   393             if (iDisplay.IsOpen())

   394             {

   395                 //Only setup brightness if display is open

   396                 trackBarBrightness.Minimum = iDisplay.MinBrightness();

   397                 trackBarBrightness.Maximum = iDisplay.MaxBrightness();

   398                 trackBarBrightness.Value = cds.Brightness;

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

   400                 trackBarBrightness.SmallChange = 1;

   401                 iDisplay.SetBrightness(cds.Brightness);

   402                 //

   403                 buttonFill.Enabled = true;

   404                 buttonClear.Enabled = true;

   405                 buttonOpen.Enabled = false;

   406                 buttonClose.Enabled = true;

   407                 trackBarBrightness.Enabled = true;

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

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

   411                 if (iDisplay.SupportPowerOnOff())

   412                 {

   413                     buttonPowerOn.Enabled = true;

   414                     buttonPowerOff.Enabled = true;

   415                 }

   416                 else

   417                 {

   418                     buttonPowerOn.Enabled = false;

   419                     buttonPowerOff.Enabled = false;

   420                 }

   422                 if (iDisplay.SupportClock())

   423                 {

   424                     buttonShowClock.Enabled = true;

   425                     buttonHideClock.Enabled = true;

   426                 }

   427                 else

   428                 {

   429                     buttonShowClock.Enabled = false;

   430                     buttonHideClock.Enabled = false;

   431                 }

   432             }

   433             else

   434             {

   435                 buttonFill.Enabled = false;

   436                 buttonClear.Enabled = false;

   437                 buttonOpen.Enabled = true;

   438                 buttonClose.Enabled = false;

   439                 trackBarBrightness.Enabled = false;

   440                 buttonPowerOn.Enabled = false;

   441                 buttonPowerOff.Enabled = false;

   442                 buttonShowClock.Enabled = false;

   443                 buttonHideClock.Enabled = false;

   444                 toolStripStatusLabelConnect.Text = "Disconnected";

   445                 toolStripStatusLabelPower.Text = "N/A";

   446             }

   447         }

   451         private void checkBoxShowBorders_CheckedChanged(object sender, EventArgs e)

   452         {

   453             //Save our show borders setting

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

   455             cds.ShowBorders = checkBoxShowBorders.Checked;

   456             Properties.Settings.Default.Save();

   457         }

   459         private void checkBoxConnectOnStartup_CheckedChanged(object sender, EventArgs e)

   460         {

   461             //Save our connect on startup setting

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

   463             Properties.Settings.Default.Save();

   464         }

   466         private void checkBoxReverseScreen_CheckedChanged(object sender, EventArgs e)

   467         {

   468             //Save our reverse screen setting

   469             cds.ReverseScreen = checkBoxReverseScreen.Checked;

   470             Properties.Settings.Default.Save();

   471         }

   473         private void MainForm_Resize(object sender, EventArgs e)

   474         {

   475             if (WindowState == FormWindowState.Minimized)

   476             {

   477                 // Do some stuff

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

   479                 iCreateBitmap = true;

   480             }

   481         }

   483         private void MainForm_FormClosing(object sender, FormClosingEventArgs e)

   484         {

   485             StopServer();

   486             e.Cancel = iClosing;

   487         }

   489         public void StartServer()

   490         {

   491             iServiceHost = new ServiceHost

   492                 (

   493                     typeof(DisplayServer),

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

   495                 );

   497             iServiceHost.AddServiceEndpoint(typeof(IDisplayService), new NetTcpBinding(SecurityMode.None,true), "DisplayService");

   498             iServiceHost.Open();

   499         }

   501         public void StopServer()

   502         {

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

   504             {

   505                 //Tell our clients

   506                 iClosing = true;

   507                 BroadcastCloseEvent();

   508             }

   509             else if (iClosing)

   510             {

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

   512                 {

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

   514                 }

   515             }

   516             else

   517             {

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

   519                 //iServiceHost.Close();

   520             }

   521         }

   523         public void BroadcastCloseEvent()

   524         {

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

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

   528             foreach (var client in iClients)

   529             {

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

   531                 {

   532                     try

   533                     {

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

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

   536                     }

   537                     catch (Exception ex)

   538                     {

   539                         inactiveClients.Add(client.Key);

   540                     }

   541                 }

   542             }

   544             if (inactiveClients.Count > 0)

   545             {

   546                 foreach (var client in inactiveClients)

   547                 {

   548                     iClients.Remove(client);

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

   550                 }

   551             }

   552         }

   554         private void buttonStartClient_Click(object sender, EventArgs e)

   555         {

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

   557             clientThread.Start();

   558             BringToFront();

   559         }

   561         private void buttonSuspend_Click(object sender, EventArgs e)

   562         {

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

   564             timer.Enabled = !timer.Enabled;

   565             if (!timer.Enabled)

   566             {

   567                 buttonSuspend.Text = "Run";

   568             }

   569             else

   570             {

   571                 buttonSuspend.Text = "Pause";

   572             }

   573         }

   575         private void buttonCloseClients_Click(object sender, EventArgs e)

   576         {

   577             BroadcastCloseEvent();

   578         }

   580         private void treeViewClients_AfterSelect(object sender, TreeViewEventArgs e)

   581         {

   583         }

   585         //Delegates are used for our thread safe method

   586         public delegate void AddClientDelegate(string aSessionId, IDisplayServiceCallback aCallback);

   587         public delegate void RemoveClientDelegate(string aSessionId);

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

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

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

   593         /// <summary>

   594         ///

   595         /// </summary>

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

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

   598         public void AddClientThreadSafe(string aSessionId, IDisplayServiceCallback aCallback)

   599         {

   600             if (this.InvokeRequired)

   601             {

   602                 //Not in the proper thread, invoke ourselves

   603                 AddClientDelegate d = new AddClientDelegate(AddClientThreadSafe);

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

   605             }

   606             else

   607             {

   608                 //We are in the proper thread

   609                 //Add this session to our collection of clients

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

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

   612                 //Add this session to our UI

   613                 UpdateClientTreeViewNode(newClient);

   614             }

   615         }

   617         /// <summary>

   618         ///

   619         /// </summary>

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

   621         public void RemoveClientThreadSafe(string aSessionId)

   622         {

   623             if (this.InvokeRequired)

   624             {

   625                 //Not in the proper thread, invoke ourselves

   626                 RemoveClientDelegate d = new RemoveClientDelegate(RemoveClientThreadSafe);

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

   628             }

   629             else

   630             {

   631                 //We are in the proper thread

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

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

   634                 {

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

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

   637                 }

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

   640                 {

   641                     //We were closing our form

   642                     //All clients are now closed

   643                     //Just resume our close operation

   644                     iClosing = false;

   645                     Close();

   646                 }

   647             }

   648         }

   650         /// <summary>

   651         ///

   652         /// </summary>

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

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

   655         public void SetTextThreadSafe(string aSessionId, TextField aTextField)

   656         {

   657             if (this.InvokeRequired)

   658             {

   659                 //Not in the proper thread, invoke ourselves

   660                 SetTextDelegate d = new SetTextDelegate(SetTextThreadSafe);

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

   662             }

   663             else

   664             {

   665                 ClientData client = iClients[aSessionId];

   666                 if (client != null)

   667                 {

   668                     //Make sure all our texts are in place

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

   670                     {

   671                         //Add a text field with proper index

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

   673                     }

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

   676                     //We are in the proper thread

   677                     //Only support two lines for now

   678                     if (aTextField.Index == 0)

   679                     {

   680                         marqueeLabelTop.Text = aTextField.Text;

   681                         marqueeLabelTop.TextAlign = aTextField.Alignment;

   682                     }

   683                     else if (aTextField.Index == 1)

   684                     {

   685                         marqueeLabelBottom.Text = aTextField.Text;

   686                         marqueeLabelBottom.TextAlign = aTextField.Alignment;

   687                     }

   690                     UpdateClientTreeViewNode(client);

   691                 }

   692             }

   693         }

   695         /// <summary>

   696         ///

   697         /// </summary>

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

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

   700         {

   701             if (this.InvokeRequired)

   702             {

   703                 //Not in the proper thread, invoke ourselves

   704                 SetTextsDelegate d = new SetTextsDelegate(SetTextsThreadSafe);

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

   706             }

   707             else

   708             {

   709                 //We are in the proper thread

   710                 ClientData client = iClients[aSessionId];

   711                 if (client != null)

   712                 {

   713                     //Populate our client with the given text fields

   714                     int j = 0;

   715                     foreach (TextField textField in aTextFields)

   716                     {

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

   718                         {

   719                             client.Texts.Add(textField);

   720                         }

   721                         else

   722                         {

   723                             client.Texts[j] = textField;

   724                         }

   725                         j++;

   726                     }

   727                     //Only support two lines for now

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

   729                     {

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

   731                         {

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

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

   734                         }

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

   736                         {

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

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

   739                         }

   740                     }

   743                     UpdateClientTreeViewNode(client);

   744                 }

   745             }

   746         }

   749         /// <summary>

   750         ///

   751         /// </summary>

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

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

   754         public void SetClientNameThreadSafe(string aSessionId, string aName)

   755         {

   756             if (this.InvokeRequired)

   757             {

   758                 //Not in the proper thread, invoke ourselves

   759                 SetClientNameDelegate d = new SetClientNameDelegate(SetClientNameThreadSafe);

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

   761             }

   762             else

   763             {

   764                 //We are in the proper thread

   765                 //Get our client

   766                 ClientData client = iClients[aSessionId];

   767                 if (client != null)

   768                 {

   769                     //Set its name

   770                     client.Name = aName;

   771                     //Update our tree-view

   772                     UpdateClientTreeViewNode(client);

   773                 }

   774             }

   775         }

   777         /// <summary>

   778         ///

   779         /// </summary>

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

   781         private void UpdateClientTreeViewNode(ClientData aClient)

   782         {

   783             if (aClient == null)

   784             {

   785                 return;

   786             }

   788             TreeNode node = null;

   789             //Check that our client node already exists

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

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

   792             if (nodes.Count()>0)

   793             {

   794                 //We already have a node for that client

   795                 node = nodes[0];

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

   797                 node.Nodes.Clear();

   798             }

   799             else

   800             {

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

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

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

   804             }

   806             if (node != null)

   807             {

   808                 //Change its name

   809                 if (aClient.Name != "")

   810                 {

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

   812                     node.Text = aClient.Name;

   813                     //Add a child with SessionId

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

   815                 }

   816                 else

   817                 {

   818                     //No name, use session ID instead

   819                     node.Text = aClient.SessionId;

   820                 }

   822                 if (aClient.Texts.Count > 0)

   823                 {

   824                     //Create root node for our texts

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

   826                     node.Nodes.Add(textsRoot);

   827                     //For each text add a new entry

   828                     foreach (TextField field in aClient.Texts)

   829                     {

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

   831                     }

   832                 }

   834                 node.ExpandAll();

   835             }

   836         }

   838         private void buttonAddRow_Click(object sender, EventArgs e)

   839         {

   840             if (tableLayoutPanel.RowCount < 6)

   841             {

   842                 tableLayoutPanel.RowCount++;

   843                 CheckFontHeight();

   844             }

   845         }

   847         private void buttonRemoveRow_Click(object sender, EventArgs e)

   848         {

   849             if (tableLayoutPanel.RowCount > 1)

   850             {

   851                 tableLayoutPanel.RowCount--;

   852                 CheckFontHeight();

   853             }

   854         }

   856         private void buttonAddColumn_Click(object sender, EventArgs e)

   857         {

   858             if (tableLayoutPanel.ColumnCount < 8)

   859             {

   860                 tableLayoutPanel.ColumnCount++;

   861                 //CheckFontHeight();

   862             }

   863         }

   865         private void buttonRemoveColumn_Click(object sender, EventArgs e)

   866         {

   867             if (tableLayoutPanel.ColumnCount > 1)

   868             {

   869                 tableLayoutPanel.ColumnCount--;

   870                 //CheckFontHeight();

   871             }

   872         }

   874         private void buttonAlignLeft_Click(object sender, EventArgs e)

   875         {

   876             marqueeLabelTop.TextAlign = ContentAlignment.MiddleLeft;

   877             marqueeLabelBottom.TextAlign = ContentAlignment.MiddleLeft;

   878         }

   880         private void buttonAlignCenter_Click(object sender, EventArgs e)

   881         {

   882             marqueeLabelTop.TextAlign = ContentAlignment.MiddleCenter;

   883             marqueeLabelBottom.TextAlign = ContentAlignment.MiddleCenter;

   884         }

   886         private void buttonAlignRight_Click(object sender, EventArgs e)

   887         {

   888             marqueeLabelTop.TextAlign = ContentAlignment.MiddleRight;

   889             marqueeLabelBottom.TextAlign = ContentAlignment.MiddleRight;

   890         }

   892         private void comboBoxDisplayType_SelectedIndexChanged(object sender, EventArgs e)

   893         {

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

   895             cds.DisplayType = comboBoxDisplayType.SelectedIndex;

   896             Properties.Settings.Default.Save();

   897             if (iDisplay.IsOpen())

   898             {

   899                 OpenDisplayConnection();

   900             }

   901             else

   902             {

   903                 UpdateStatus();

   904             }

   905         }

   908         private void maskedTextBoxTimerInterval_TextChanged(object sender, EventArgs e)

   909         {

   910             if (maskedTextBoxTimerInterval.Text != "")

   911             {

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

   914                 if (interval > 0)

   915                 {

   916                     timer.Interval = interval;

   917                     cds.TimerInterval = timer.Interval;

   918                     Properties.Settings.Default.Save();

   919                 }

   920             }

   921         }

   923         private void buttonPowerOn_Click(object sender, EventArgs e)

   924         {

   925             iDisplay.PowerOn();

   926         }

   928         private void buttonPowerOff_Click(object sender, EventArgs e)

   929         {

   930             iDisplay.PowerOff();

   931         }

   933         private void buttonShowClock_Click(object sender, EventArgs e)

   934         {

   935             iDisplay.ShowClock();

   936         }

   938         private void buttonHideClock_Click(object sender, EventArgs e)

   939         {

   940             iDisplay.HideClock();

   941         }

   943     }

   945     /// <summary>

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

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

   948     /// </summary>

   949     public class ClientData

   950     {

   951         public ClientData(string aSessionId, IDisplayServiceCallback aCallback)

   952         {

   953             SessionId = aSessionId;

   954             Name = "";

   955             Texts = new List<TextField>();

   956             Callback = aCallback;

   957         }

   959         public string SessionId { get; set; }

   960         public string Name { get; set; }

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

   962         public IDisplayServiceCallback Callback { get; set; }

   963     }

   964 }

author	sl
	Mon, 01 Sep 2014 19:23:36 +0200
changeset 54	fdda7642776a
parent 53	f7ad2dce46a9
child 55	b5ed2e29be23
permissions	-rw-r--r--