SharpDisplayManager: Server/MainForm.cs@fd0bb39a7818

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

    25     //Delegates are used for our thread safe method

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

    27     public delegate void RemoveClientDelegate(string aSessionId);

    28     public delegate void SetTextDelegate(string SessionId, DataField aField);

    29     public delegate void SetBitmapDelegate(string SessionId, DataField aField);

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

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

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

    35     /// <summary>

    36     /// Our Display manager main form

    37     /// </summary>

    38     public partial class MainForm : Form

    39     {

    41         DateTime LastTickTime;

    42         Display iDisplay;

    43         System.Drawing.Bitmap iBmp;

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

    45         ServiceHost iServiceHost;

    46         // Our collection of clients sorted by session id.

    47         public Dictionary<string, ClientData> iClients;

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

    49         public string iCurrentClientSessionId;

    50         ClientData iCurrentClientData;

    51         //

    52         public bool iClosing;

    53         //Function pointer for pixel color filtering

    54         ColorProcessingDelegate iColorFx;

    55         //Function pointer for pixel X coordinate intercept

    56         CoordinateTranslationDelegate iScreenX;

    57         //Function pointer for pixel Y coordinate intercept

    58         CoordinateTranslationDelegate iScreenY;

    60         public MainForm()

    61         {

    62             iCurrentClientSessionId = "";

    63             iCurrentClientData = null;

    64             LastTickTime = DateTime.Now;

    65             iDisplay = new Display();

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

    68             InitializeComponent();

    69             UpdateStatus();

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

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

    72             iCreateBitmap = false;

    73         }

    75         private void MainForm_Load(object sender, EventArgs e)

    76         {

    77             StartServer();

    79             if (Properties.Settings.Default.DisplayConnectOnStartup)

    80             {

    81                 OpenDisplayConnection();

    82             }

    83         }

    85         /// <summary>

    86         /// Set our current client.

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

    88         /// </summary>

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

    90         void SetCurrentClient(string aSessionId)

    91         {

    92             if (aSessionId == iCurrentClientSessionId)

    93             {

    94                 //Given client is already the current one.

    95                 //Don't bother changing anything then.

    96                 return;

    97             }

    99             //Set current client ID.

   100             iCurrentClientSessionId = aSessionId;

   101             //Fetch and set current client data.

   102             iCurrentClientData = iClients[aSessionId];

   103             //Apply layout and set data fields.

   104             UpdateTableLayoutPanel(iCurrentClientData);

   105         }

   107         private void buttonFont_Click(object sender, EventArgs e)

   108         {

   109             //fontDialog.ShowColor = true;

   110             //fontDialog.ShowApply = true;

   111             fontDialog.ShowEffects = true;

   112             MarqueeLabel label = (MarqueeLabel)tableLayoutPanel.Controls[0];

   113             fontDialog.Font = label.Font;

   115             fontDialog.FixedPitchOnly = checkBoxFixedPitchFontOnly.Checked;

   117             //fontDialog.ShowHelp = true;

   119             //fontDlg.MaxSize = 40;

   120             //fontDlg.MinSize = 22;

   122             //fontDialog.Parent = this;

   123             //fontDialog.StartPosition = FormStartPosition.CenterParent;

   125             //DlgBox.ShowDialog(fontDialog);

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

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

   129             {

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

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

   134                 foreach (MarqueeLabel ctrl in tableLayoutPanel.Controls)

   135                 {

   136                     ctrl.Font = fontDialog.Font;

   137                 }

   138                 cds.Font = fontDialog.Font;

   139                 Properties.Settings.Default.Save();

   140                 //

   141                 CheckFontHeight();

   142             }

   143         }

   145         /// <summary>

   146         ///

   147         /// </summary>

   148         void CheckFontHeight()

   149         {

   150             //Show font height and width

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

   152             float charWidth = IsFixedWidth(cds.Font);

   153             if (charWidth == 0.0f)

   154             {

   155                 labelFontWidth.Visible = false;

   156             }

   157             else

   158             {

   159                 labelFontWidth.Visible = true;

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

   161             }

   163             MarqueeLabel label = null;

   164             //Get the first label control we can find

   165             foreach (Control ctrl in tableLayoutPanel.Controls)

   166             {

   167                 if (ctrl is MarqueeLabel)

   168                 {

   169                     label = (MarqueeLabel)ctrl;

   170                     break;

   171                 }

   172             }

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

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

   176             {

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

   178                 labelWarning.Visible = true;

   179             }

   180             else

   181             {

   182                 labelWarning.Visible = false;

   183             }

   185         }

   187         private void buttonCapture_Click(object sender, EventArgs e)

   188         {

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

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

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

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

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

   196             /*

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

   198             using (MemoryStream memory = new MemoryStream())

   199             {

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

   201                 {

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

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

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

   205                 }

   206             }

   207              */

   209         }

   211         private void CheckForRequestResults()

   212         {

   213             if (iDisplay.IsRequestPending())

   214             {

   215                 switch (iDisplay.AttemptRequestCompletion())

   216                 {

   217                     case Display.TMiniDisplayRequest.EMiniDisplayRequestFirmwareRevision:

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

   219                         //Issue next request then

   220                         iDisplay.RequestPowerSupplyStatus();

   221                         break;

   223                     case Display.TMiniDisplayRequest.EMiniDisplayRequestPowerSupplyStatus:

   224                         if (iDisplay.PowerSupplyStatus())

   225                         {

   226                             toolStripStatusLabelPower.Text = "ON";

   227                         }

   228                         else

   229                         {

   230                             toolStripStatusLabelPower.Text = "OFF";

   231                         }

   232                         //Issue next request then

   233                         iDisplay.RequestDeviceId();

   234                         break;

   236                     case Display.TMiniDisplayRequest.EMiniDisplayRequestDeviceId:

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

   238                         //No more request to issue

   239                         break;

   240                 }

   241             }

   242         }

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

   245         {

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

   247             {

   248                 return 0xFFFFFFFF;

   249             }

   250             return 0x00000000;

   251         }

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

   254         {

   255             return aPixel;

   256         }

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

   259         {

   260             return ~aPixel;

   261         }

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

   264         {

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

   266             {

   267                 return ~aPixel;

   268             }

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

   270             {

   271                 return ~aPixel;

   272             }

   273             return 0x00000000;

   274         }

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

   278         {

   279             return aBmp.Width - aX - 1;

   280         }

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

   283         {

   284             return iBmp.Height - aY - 1;

   285         }

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

   288         {

   289             return aX;

   290         }

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

   293         {

   294             return aY;

   295         }

   297         /// <summary>

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

   299         /// </summary>

   300         private void SetupPixelDelegates()

   301         {

   302             //Select our pixel processing routine

   303             if (cds.InverseColors)

   304             {

   305                 //iColorFx = ColorChessboard;

   306                 iColorFx = ColorInversed;

   307             }

   308             else

   309             {

   310                 iColorFx = ColorWhiteIsOn;

   311             }

   313             //Select proper coordinate translation functions

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

   315             if (cds.ReverseScreen)

   316             {

   317                 iScreenX = ScreenReversedX;

   318                 iScreenY = ScreenReversedY;

   319             }

   320             else

   321             {

   322                 iScreenX = ScreenX;

   323                 iScreenY = ScreenY;

   324             }

   326         }

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

   329         private void timer_Tick(object sender, EventArgs e)

   330         {

   331             //Update our animations

   332             DateTime NewTickTime = DateTime.Now;

   334             //Update animation for all our marquees

   335             foreach (Control ctrl in tableLayoutPanel.Controls)

   336             {

   337                 if (ctrl is MarqueeLabel)

   338                 {

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

   340                 }

   341             }

   344             //Update our display

   345             if (iDisplay.IsOpen())

   346             {

   347                 CheckForRequestResults();

   349                 //Draw to bitmap

   350                 if (iCreateBitmap)

   351                 {

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

   353                 }

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

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

   357                 //Send it to our display

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

   359                 {

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

   361                     {

   362                         unchecked

   363                         {

   364                             //Get our processed pixel coordinates

   365                             int x = iScreenX(iBmp, i);

   366                             int y = iScreenY(iBmp, j);

   367                             //Get pixel color

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

   369                             //Apply color effects

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

   371                             //Now set our pixel

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

   373                         }

   374                     }

   375                 }

   377                 iDisplay.SwapBuffers();

   379             }

   381             //Compute instant FPS

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

   384             LastTickTime = NewTickTime;

   386         }

   388         private void OpenDisplayConnection()

   389         {

   390             CloseDisplayConnection();

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

   393             {

   394                 UpdateStatus();

   395                 iDisplay.RequestFirmwareRevision();

   396             }

   397             else

   398             {

   399                 UpdateStatus();

   400                 toolStripStatusLabelConnect.Text = "Connection error";

   401             }

   402         }

   404         private void CloseDisplayConnection()

   405         {

   406             iDisplay.Close();

   407             UpdateStatus();

   408         }

   410         private void buttonOpen_Click(object sender, EventArgs e)

   411         {

   412             OpenDisplayConnection();

   413         }

   415         private void buttonClose_Click(object sender, EventArgs e)

   416         {

   417             CloseDisplayConnection();

   418         }

   420         private void buttonClear_Click(object sender, EventArgs e)

   421         {

   422             iDisplay.Clear();

   423             iDisplay.SwapBuffers();

   424         }

   426         private void buttonFill_Click(object sender, EventArgs e)

   427         {

   428             iDisplay.Fill();

   429             iDisplay.SwapBuffers();

   430         }

   432         private void trackBarBrightness_Scroll(object sender, EventArgs e)

   433         {

   434             cds.Brightness = trackBarBrightness.Value;

   435             Properties.Settings.Default.Save();

   436             iDisplay.SetBrightness(trackBarBrightness.Value);

   438         }

   441         /// <summary>

   442         /// CDS stands for Current Display Settings

   443         /// </summary>

   444         private DisplaySettings cds

   445         {

   446             get

   447             {

   448                 DisplaysSettings settings = Properties.Settings.Default.DisplaysSettings;

   449                 if (settings == null)

   450                 {

   451                     settings = new DisplaysSettings();

   452                     settings.Init();

   453                     Properties.Settings.Default.DisplaysSettings = settings;

   454                 }

   456                 //Make sure all our settings have been created

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

   458                 {

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

   460                 }

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

   463                 return displaySettings;

   464             }

   465         }

   467         /// <summary>

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

   469         /// </summary>

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

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

   472         public float IsFixedWidth(Font ft)

   473         {

   474             Graphics g = CreateGraphics();

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

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

   478             bool fixedWidth = true;

   480             foreach (char c in charSizes)

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

   482                     fixedWidth = false;

   484             if (fixedWidth)

   485             {

   486                 return charWidth;

   487             }

   489             return 0.0f;

   490         }

   492         private void UpdateStatus()

   493         {

   494             //Synchronize UI with settings

   495             //Load settings

   496             checkBoxShowBorders.Checked = cds.ShowBorders;

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

   499             //Set the proper font to each of our labels

   500             foreach (MarqueeLabel ctrl in tableLayoutPanel.Controls)

   501             {

   502                 ctrl.Font = cds.Font;

   503             }

   505             CheckFontHeight();

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

   507             checkBoxReverseScreen.Checked = cds.ReverseScreen;

   508             checkBoxInverseColors.Checked = cds.InverseColors;

   509             comboBoxDisplayType.SelectedIndex = cds.DisplayType;

   510             timer.Interval = cds.TimerInterval;

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

   512             //

   513             SetupPixelDelegates();

   515             if (iDisplay.IsOpen())

   516             {

   517                 //Only setup brightness if display is open

   518                 trackBarBrightness.Minimum = iDisplay.MinBrightness();

   519                 trackBarBrightness.Maximum = iDisplay.MaxBrightness();

   520                 trackBarBrightness.Value = cds.Brightness;

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

   522                 trackBarBrightness.SmallChange = 1;

   523                 iDisplay.SetBrightness(cds.Brightness);

   524                 //

   525                 buttonFill.Enabled = true;

   526                 buttonClear.Enabled = true;

   527                 buttonOpen.Enabled = false;

   528                 buttonClose.Enabled = true;

   529                 trackBarBrightness.Enabled = true;

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

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

   533                 if (iDisplay.SupportPowerOnOff())

   534                 {

   535                     buttonPowerOn.Enabled = true;

   536                     buttonPowerOff.Enabled = true;

   537                 }

   538                 else

   539                 {

   540                     buttonPowerOn.Enabled = false;

   541                     buttonPowerOff.Enabled = false;

   542                 }

   544                 if (iDisplay.SupportClock())

   545                 {

   546                     buttonShowClock.Enabled = true;

   547                     buttonHideClock.Enabled = true;

   548                 }

   549                 else

   550                 {

   551                     buttonShowClock.Enabled = false;

   552                     buttonHideClock.Enabled = false;

   553                 }

   554             }

   555             else

   556             {

   557                 buttonFill.Enabled = false;

   558                 buttonClear.Enabled = false;

   559                 buttonOpen.Enabled = true;

   560                 buttonClose.Enabled = false;

   561                 trackBarBrightness.Enabled = false;

   562                 buttonPowerOn.Enabled = false;

   563                 buttonPowerOff.Enabled = false;

   564                 buttonShowClock.Enabled = false;

   565                 buttonHideClock.Enabled = false;

   566                 toolStripStatusLabelConnect.Text = "Disconnected";

   567                 toolStripStatusLabelPower.Text = "N/A";

   568             }

   569         }

   573         private void checkBoxShowBorders_CheckedChanged(object sender, EventArgs e)

   574         {

   575             //Save our show borders setting

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

   577             cds.ShowBorders = checkBoxShowBorders.Checked;

   578             Properties.Settings.Default.Save();

   579             CheckFontHeight();

   580         }

   582         private void checkBoxConnectOnStartup_CheckedChanged(object sender, EventArgs e)

   583         {

   584             //Save our connect on startup setting

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

   586             Properties.Settings.Default.Save();

   587         }

   589         private void checkBoxReverseScreen_CheckedChanged(object sender, EventArgs e)

   590         {

   591             //Save our reverse screen setting

   592             cds.ReverseScreen = checkBoxReverseScreen.Checked;

   593             Properties.Settings.Default.Save();

   594             SetupPixelDelegates();

   595         }

   597         private void checkBoxInverseColors_CheckedChanged(object sender, EventArgs e)

   598         {

   599             //Save our inverse colors setting

   600             cds.InverseColors = checkBoxInverseColors.Checked;

   601             Properties.Settings.Default.Save();

   602             SetupPixelDelegates();

   603         }

   605         private void MainForm_Resize(object sender, EventArgs e)

   606         {

   607             if (WindowState == FormWindowState.Minimized)

   608             {

   609                 // Do some stuff

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

   611                 iCreateBitmap = true;

   612             }

   613         }

   615         private void MainForm_FormClosing(object sender, FormClosingEventArgs e)

   616         {

   617             StopServer();

   618             e.Cancel = iClosing;

   619         }

   621         public void StartServer()

   622         {

   623             iServiceHost = new ServiceHost

   624                 (

   625                     typeof(Session),

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

   627                 );

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

   630             iServiceHost.Open();

   631         }

   633         public void StopServer()

   634         {

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

   636             {

   637                 //Tell our clients

   638                 iClosing = true;

   639                 BroadcastCloseEvent();

   640             }

   641             else if (iClosing)

   642             {

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

   644                 {

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

   646                 }

   647             }

   648             else

   649             {

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

   651                 //iServiceHost.Close();

   652             }

   653         }

   655         public void BroadcastCloseEvent()

   656         {

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

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

   660             foreach (var client in iClients)

   661             {

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

   663                 {

   664                     try

   665                     {

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

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

   668                     }

   669                     catch (Exception ex)

   670                     {

   671                         inactiveClients.Add(client.Key);

   672                     }

   673                 }

   674             }

   676             if (inactiveClients.Count > 0)

   677             {

   678                 foreach (var client in inactiveClients)

   679                 {

   680                     iClients.Remove(client);

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

   682                 }

   683             }

   684         }

   686         private void buttonStartClient_Click(object sender, EventArgs e)

   687         {

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

   689             clientThread.Start();

   690             BringToFront();

   691         }

   693         private void buttonSuspend_Click(object sender, EventArgs e)

   694         {

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

   696             timer.Enabled = !timer.Enabled;

   697             if (!timer.Enabled)

   698             {

   699                 buttonSuspend.Text = "Run";

   700             }

   701             else

   702             {

   703                 buttonSuspend.Text = "Pause";

   704             }

   705         }

   707         private void buttonCloseClients_Click(object sender, EventArgs e)

   708         {

   709             BroadcastCloseEvent();

   710         }

   712         private void treeViewClients_AfterSelect(object sender, TreeViewEventArgs e)

   713         {

   715         }

   718         /// <summary>

   719         ///

   720         /// </summary>

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

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

   723         public void AddClientThreadSafe(string aSessionId, ICallback aCallback)

   724         {

   725             if (this.InvokeRequired)

   726             {

   727                 //Not in the proper thread, invoke ourselves

   728                 AddClientDelegate d = new AddClientDelegate(AddClientThreadSafe);

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

   730             }

   731             else

   732             {

   733                 //We are in the proper thread

   734                 //Add this session to our collection of clients

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

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

   737                 //Add this session to our UI

   738                 UpdateClientTreeViewNode(newClient);

   739             }

   740         }

   742         /// <summary>

   743         ///

   744         /// </summary>

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

   746         public void RemoveClientThreadSafe(string aSessionId)

   747         {

   748             if (this.InvokeRequired)

   749             {

   750                 //Not in the proper thread, invoke ourselves

   751                 RemoveClientDelegate d = new RemoveClientDelegate(RemoveClientThreadSafe);

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

   753             }

   754             else

   755             {

   756                 //We are in the proper thread

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

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

   759                 {

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

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

   762                 }

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

   765                 {

   766                     //We were closing our form

   767                     //All clients are now closed

   768                     //Just resume our close operation

   769                     iClosing = false;

   770                     Close();

   771                 }

   772             }

   773         }

   775         /// <summary>

   776         ///

   777         /// </summary>

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

   779         /// <param name="aLayout"></param>

   780         public void SetClientLayoutThreadSafe(string aSessionId, TableLayout aLayout)

   781         {

   782             if (this.InvokeRequired)

   783             {

   784                 //Not in the proper thread, invoke ourselves

   785                 SetLayoutDelegate d = new SetLayoutDelegate(SetClientLayoutThreadSafe);

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

   787             }

   788             else

   789             {

   790                 ClientData client = iClients[aSessionId];

   791                 if (client != null)

   792                 {

   793                     client.Layout = aLayout;

   794                     UpdateTableLayoutPanel(client);

   795                     //

   796                     UpdateClientTreeViewNode(client);

   797                 }

   798             }

   799         }

   801         /// <summary>

   802         ///

   803         /// </summary>

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

   805         /// <param name="aField"></param>

   806         public void SetClientTextThreadSafe(string aSessionId, DataField aField)

   807         {

   808             if (this.InvokeRequired)

   809             {

   810                 //Not in the proper thread, invoke ourselves

   811                 SetTextDelegate d = new SetTextDelegate(SetClientTextThreadSafe);

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

   813             }

   814             else

   815             {

   816                 SetCurrentClient(aSessionId);

   817                 ClientData client = iClients[aSessionId];

   818                 if (client != null)

   819                 {

   820                     //Make sure all our texts are in place

   821                     while (client.Fields.Count < (aField.Index + 1))

   822                     {

   823                         //Add a text field with proper index

   824                         client.Fields.Add(new DataField(client.Fields.Count));

   825                     }

   826                     client.Fields[aField.Index] = aField;

   828                     //We are in the proper thread

   829                     if (tableLayoutPanel.Controls[aField.Index] is MarqueeLabel)

   830                     {

   831                         MarqueeLabel label = (MarqueeLabel)tableLayoutPanel.Controls[aField.Index];

   832                         label.Text = aField.Text;

   833                         label.TextAlign = aField.Alignment;

   834                     }

   835                     else

   836                     {

   837                         //Wrong control type, re-create them all

   838                         UpdateTableLayoutPanel(iCurrentClientData);

   839                     }

   840                     //

   841                     UpdateClientTreeViewNode(client);

   842                 }

   843             }

   844         }

   846         /// <summary>

   847         ///

   848         /// </summary>

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

   850         public void SetClientTextsThreadSafe(string aSessionId, System.Collections.Generic.IList<DataField> aFields)

   851         {

   852             if (this.InvokeRequired)

   853             {

   854                 //Not in the proper thread, invoke ourselves

   855                 SetTextsDelegate d = new SetTextsDelegate(SetClientTextsThreadSafe);

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

   857             }

   858             else

   859             {

   860                 SetCurrentClient(aSessionId);

   861                 //We are in the proper thread

   862                 ClientData client = iClients[aSessionId];

   863                 if (client != null)

   864                 {

   865                     //Populate our client with the given text fields

   866                     foreach (DataField field in aFields)

   867                     {

   868                         //Make sure all our texts are in place

   869                         while (client.Fields.Count < (field.Index + 1))

   870                         {

   871                             //Add a text field with proper index

   872                             client.Fields.Add(new DataField(client.Fields.Count));

   873                         }

   874                         client.Fields[field.Index] = field;

   875                     }

   876                     //Put each our text fields in a label control

   877                     foreach (DataField field in aFields)

   878                     {

   879                         if (tableLayoutPanel.Controls[field.Index] is MarqueeLabel)

   880                         {

   881                             //Proper control type just update the text

   882                             MarqueeLabel label = (MarqueeLabel)tableLayoutPanel.Controls[field.Index];

   883                             label.Text = field.Text;

   884                             label.TextAlign = field.Alignment;

   885                         }

   886                         else

   887                         {

   888                             //Wrong control for the given field

   889                             //Update our layout thus re-creating our controls

   890                             UpdateTableLayoutPanel(iCurrentClientData);

   891                             break; //No need to keep on looping layout update will take care of everything

   892                         }

   893                     }

   895                     UpdateClientTreeViewNode(client);

   896                 }

   897             }

   898         }

   900         /// <summary>

   901         ///

   902         /// </summary>

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

   904         /// <param name="aTextField"></param>

   905         public void SetClientBitmapThreadSafe(string aSessionId, DataField aField)

   906         {

   907             if (this.InvokeRequired)

   908             {

   909                 //Not in the proper thread, invoke ourselves

   910                 SetBitmapDelegate d = new SetBitmapDelegate(SetClientBitmapThreadSafe);

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

   912             }

   913             else

   914             {

   915                 SetCurrentClient(aSessionId);

   916                 ClientData client = iClients[aSessionId];

   917                 if (client != null)

   918                 {

   919                     //Make sure all our texts are in place

   920                     while (client.Fields.Count < (aField.Index + 1))

   921                     {

   922                         //Add a text field with proper index

   923                         client.Fields.Add(new DataField(client.Fields.Count));

   924                     }

   926                     client.Fields[aField.Index] = aField;

   928                     //We are in the proper thread

   929                     if (tableLayoutPanel.Controls[aField.Index] is PictureBox)

   930                     {

   931                         PictureBox pictureBox = (PictureBox)tableLayoutPanel.Controls[aField.Index];

   932                         pictureBox.Image = aField.Bitmap;

   933                     }

   934                     else

   935                     {

   936                         //Wrong control type re-create them all

   937                         UpdateTableLayoutPanel(iCurrentClientData);

   938                     }

   939                     //

   940                     UpdateClientTreeViewNode(client);

   941                 }

   942             }

   943         }

   947         /// <summary>

   948         ///

   949         /// </summary>

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

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

   952         public void SetClientNameThreadSafe(string aSessionId, string aName)

   953         {

   954             if (this.InvokeRequired)

   955             {

   956                 //Not in the proper thread, invoke ourselves

   957                 SetClientNameDelegate d = new SetClientNameDelegate(SetClientNameThreadSafe);

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

   959             }

   960             else

   961             {

   962                 //We are in the proper thread

   963                 //Get our client

   964                 ClientData client = iClients[aSessionId];

   965                 if (client != null)

   966                 {

   967                     //Set its name

   968                     client.Name = aName;

   969                     //Update our tree-view

   970                     UpdateClientTreeViewNode(client);

   971                 }

   972             }

   973         }

   975         /// <summary>

   976         ///

   977         /// </summary>

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

   979         private void UpdateClientTreeViewNode(ClientData aClient)

   980         {

   981             if (aClient == null)

   982             {

   983                 return;

   984             }

   986             TreeNode node = null;

   987             //Check that our client node already exists

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

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

   990             if (nodes.Count()>0)

   991             {

   992                 //We already have a node for that client

   993                 node = nodes[0];

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

   995                 node.Nodes.Clear();

   996             }

   997             else

   998             {

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

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

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

  1002             }

  1004             if (node != null)

  1005             {

  1006                 //Change its name

  1007                 if (aClient.Name != "")

  1008                 {

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

  1010                     node.Text = aClient.Name;

  1011                     //Add a child with SessionId

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

  1013                 }

  1014                 else

  1015                 {

  1016                     //No name, use session ID instead

  1017                     node.Text = aClient.SessionId;

  1018                 }

  1020                 if (aClient.Fields.Count > 0)

  1021                 {

  1022                     //Create root node for our texts

  1023                     TreeNode textsRoot = new TreeNode("Fields");

  1024                     node.Nodes.Add(textsRoot);

  1025                     //For each text add a new entry

  1026                     foreach (DataField field in aClient.Fields)

  1027                     {

  1028                         if (!field.HasBitmap)

  1029                         {

  1030                             DataField textField = (DataField)field;

  1031                             textsRoot.Nodes.Add(new TreeNode("[Text]" + textField.Text));

  1032                         }

  1033                         else

  1034                         {

  1035                             textsRoot.Nodes.Add(new TreeNode("[Bitmap]"));

  1036                         }

  1037                     }

  1038                 }

  1040                 node.ExpandAll();

  1041             }

  1042         }

  1044         private void buttonAddRow_Click(object sender, EventArgs e)

  1045         {

  1046             if (tableLayoutPanel.RowCount < 6)

  1047             {

  1048                 UpdateTableLayoutPanel(tableLayoutPanel.ColumnCount, tableLayoutPanel.RowCount + 1);

  1049             }

  1050         }

  1052         private void buttonRemoveRow_Click(object sender, EventArgs e)

  1053         {

  1054             if (tableLayoutPanel.RowCount > 1)

  1055             {

  1056                 UpdateTableLayoutPanel(tableLayoutPanel.ColumnCount, tableLayoutPanel.RowCount - 1);

  1057             }

  1059             UpdateTableLayoutRowStyles();

  1060         }

  1062         private void buttonAddColumn_Click(object sender, EventArgs e)

  1063         {

  1064             if (tableLayoutPanel.ColumnCount < 8)

  1065             {

  1066                 UpdateTableLayoutPanel(tableLayoutPanel.ColumnCount + 1, tableLayoutPanel.RowCount);

  1067             }

  1068         }

  1070         private void buttonRemoveColumn_Click(object sender, EventArgs e)

  1071         {

  1072             if (tableLayoutPanel.ColumnCount > 1)

  1073             {

  1074                 UpdateTableLayoutPanel(tableLayoutPanel.ColumnCount - 1, tableLayoutPanel.RowCount);

  1075             }

  1076         }

  1079         /// <summary>

  1080         /// Update our table layout row styles to make sure each rows have similar height

  1081         /// </summary>

  1082         private void UpdateTableLayoutRowStyles()

  1083         {

  1084             foreach (RowStyle rowStyle in tableLayoutPanel.RowStyles)

  1085             {

  1086                 rowStyle.SizeType = SizeType.Percent;

  1087                 rowStyle.Height = 100 / tableLayoutPanel.RowCount;

  1088             }

  1089         }

  1091         /// DEPRECATED

  1092         /// <summary>

  1093         /// Empty and recreate our table layout with the given number of columns and rows.

  1094         /// Sizes of rows and columns are uniform.

  1095         /// </summary>

  1096         /// <param name="aColumn"></param>

  1097         /// <param name="aRow"></param>

  1098         private void UpdateTableLayoutPanel(int aColumn, int aRow)

  1099         {

  1100             tableLayoutPanel.Controls.Clear();

  1101             tableLayoutPanel.RowStyles.Clear();

  1102             tableLayoutPanel.ColumnStyles.Clear();

  1103             tableLayoutPanel.RowCount = 0;

  1104             tableLayoutPanel.ColumnCount = 0;

  1106             while (tableLayoutPanel.RowCount < aRow)

  1107             {

  1108                 tableLayoutPanel.RowCount++;

  1109             }

  1111             while (tableLayoutPanel.ColumnCount < aColumn)

  1112             {

  1113                 tableLayoutPanel.ColumnCount++;

  1114             }

  1116             for (int i = 0; i < tableLayoutPanel.ColumnCount; i++)

  1117             {

  1118                 //Create our column styles

  1119                 this.tableLayoutPanel.ColumnStyles.Add(new System.Windows.Forms.ColumnStyle(System.Windows.Forms.SizeType.Percent, 100 / tableLayoutPanel.ColumnCount));

  1121                 for (int j = 0; j < tableLayoutPanel.RowCount; j++)

  1122                 {

  1123                     if (i == 0)

  1124                     {

  1125                         //Create our row styles

  1126                         this.tableLayoutPanel.RowStyles.Add(new System.Windows.Forms.RowStyle(System.Windows.Forms.SizeType.Percent, 100 / tableLayoutPanel.RowCount));

  1127                     }

  1129                     MarqueeLabel control = new SharpDisplayManager.MarqueeLabel();

  1130                     control.AutoEllipsis = true;

  1131                     control.AutoSize = true;

  1132                     control.BackColor = System.Drawing.Color.Transparent;

  1133                     control.Dock = System.Windows.Forms.DockStyle.Fill;

  1134                     control.Location = new System.Drawing.Point(1, 1);

  1135                     control.Margin = new System.Windows.Forms.Padding(0);

  1136                     control.Name = "marqueeLabelCol" + aColumn + "Row" + aRow;

  1137                     control.OwnTimer = false;

  1138                     control.PixelsPerSecond = 64;

  1139                     control.Separator = "|";

  1140                     //control.Size = new System.Drawing.Size(254, 30);

  1141                     //control.TabIndex = 2;

  1142                     control.Font = cds.Font;

  1143                     control.Text = "ABCDEFGHIJKLMNOPQRST-0123456789";

  1144                     control.TextAlign = System.Drawing.ContentAlignment.MiddleCenter;

  1145                     control.UseCompatibleTextRendering = true;

  1146                     //

  1147                     tableLayoutPanel.Controls.Add(control, i, j);

  1148                 }

  1149             }

  1151             CheckFontHeight();

  1152         }

  1155         /// <summary>

  1156         /// Update our display table layout.

  1157         /// </summary>

  1158         /// <param name="aLayout"></param>

  1159         private void UpdateTableLayoutPanel(ClientData aClient)

  1160         {

  1161             TableLayout layout = aClient.Layout;

  1162             int fieldCount = 0;

  1164             tableLayoutPanel.Controls.Clear();

  1165             tableLayoutPanel.RowStyles.Clear();

  1166             tableLayoutPanel.ColumnStyles.Clear();

  1167             tableLayoutPanel.RowCount = 0;

  1168             tableLayoutPanel.ColumnCount = 0;

  1170             while (tableLayoutPanel.RowCount < layout.Rows.Count)

  1171             {

  1172                 tableLayoutPanel.RowCount++;

  1173             }

  1175             while (tableLayoutPanel.ColumnCount < layout.Columns.Count)

  1176             {

  1177                 tableLayoutPanel.ColumnCount++;

  1178             }

  1180             for (int i = 0; i < tableLayoutPanel.ColumnCount; i++)

  1181             {

  1182                 //Create our column styles

  1183                 this.tableLayoutPanel.ColumnStyles.Add(layout.Columns[i]);

  1185                 for (int j = 0; j < tableLayoutPanel.RowCount; j++)

  1186                 {

  1187                     if (i == 0)

  1188                     {

  1189                         //Create our row styles

  1190                         this.tableLayoutPanel.RowStyles.Add(layout.Rows[j]);

  1191                     }

  1193                     //Check if we already have a control

  1194                     Control existingControl = tableLayoutPanel.GetControlFromPosition(i,j);

  1195                     if (existingControl!=null)

  1196                     {

  1197                         //We already have a control in that cell as a results of row/col spanning

  1198                         //Move on to next cell then

  1199                         continue;

  1200                     }

  1202                     fieldCount++;

  1204                     //Check if a client field already exists for that cell

  1205                     if (aClient.Fields.Count <= tableLayoutPanel.Controls.Count)

  1206                     {

  1207                         //No client field specified, create a text field by default

  1208                         aClient.Fields.Add(new DataField(aClient.Fields.Count));

  1209                     }

  1211                     //Create a control corresponding to the field specified for that cell

  1212                     DataField field = aClient.Fields[tableLayoutPanel.Controls.Count];

  1213                     Control control = CreateControlForDataField(field);

  1215                     //Add newly created control to our table layout at the specified row and column

  1216                     tableLayoutPanel.Controls.Add(control, i, j);

  1217                     //Make sure we specify row and column span for that new control

  1218                     tableLayoutPanel.SetRowSpan(control,field.RowSpan);

  1219                     tableLayoutPanel.SetColumnSpan(control, field.ColumnSpan);

  1220                 }

  1221             }

  1223             //

  1224             while (aClient.Fields.Count > fieldCount)

  1225             {

  1226                 //We have too much fields for this layout

  1227                 //Just discard them until we get there

  1228                 aClient.Fields.RemoveAt(aClient.Fields.Count-1);

  1229             }

  1231             CheckFontHeight();

  1232         }

  1234         /// <summary>

  1235         /// Check our type of data field and create corresponding control

  1236         /// </summary>

  1237         /// <param name="aField"></param>

  1238         private Control CreateControlForDataField(DataField aField)

  1239         {

  1240             Control control=null;

  1241             if (!aField.HasBitmap)

  1242             {

  1243                 MarqueeLabel label = new SharpDisplayManager.MarqueeLabel();

  1244                 label.AutoEllipsis = true;

  1245                 label.AutoSize = true;

  1246                 label.BackColor = System.Drawing.Color.Transparent;

  1247                 label.Dock = System.Windows.Forms.DockStyle.Fill;

  1248                 label.Location = new System.Drawing.Point(1, 1);

  1249                 label.Margin = new System.Windows.Forms.Padding(0);

  1250                 label.Name = "marqueeLabel" + aField.Index;

  1251                 label.OwnTimer = false;

  1252                 label.PixelsPerSecond = 64;

  1253                 label.Separator = "|";

  1254                 //control.Size = new System.Drawing.Size(254, 30);

  1255                 //control.TabIndex = 2;

  1256                 label.Font = cds.Font;

  1258                 label.TextAlign = System.Drawing.ContentAlignment.MiddleCenter;

  1259                 label.UseCompatibleTextRendering = true;

  1260                 label.Text = aField.Text;

  1261                 //

  1262                 control = label;

  1263             }

  1264             else

  1265             {

  1266                 //Create picture box

  1267                 PictureBox picture = new PictureBox();

  1268                 picture.AutoSize = true;

  1269                 picture.BackColor = System.Drawing.Color.Transparent;

  1270                 picture.Dock = System.Windows.Forms.DockStyle.Fill;

  1271                 picture.Location = new System.Drawing.Point(1, 1);

  1272                 picture.Margin = new System.Windows.Forms.Padding(0);

  1273                 picture.Name = "pictureBox" + aField;

  1274                 //Set our image

  1275                 picture.Image = aField.Bitmap;

  1276                 //

  1277                 control = picture;

  1278             }

  1280             return control;

  1281         }

  1284         private void buttonAlignLeft_Click(object sender, EventArgs e)

  1285         {

  1286             foreach (MarqueeLabel ctrl in tableLayoutPanel.Controls)

  1287             {

  1288                 ctrl.TextAlign = ContentAlignment.MiddleLeft;

  1289             }

  1290         }

  1292         private void buttonAlignCenter_Click(object sender, EventArgs e)

  1293         {

  1294             foreach (MarqueeLabel ctrl in tableLayoutPanel.Controls)

  1295             {

  1296                 ctrl.TextAlign = ContentAlignment.MiddleCenter;

  1297             }

  1298         }

  1300         private void buttonAlignRight_Click(object sender, EventArgs e)

  1301         {

  1302             foreach (MarqueeLabel ctrl in tableLayoutPanel.Controls)

  1303             {

  1304                 ctrl.TextAlign = ContentAlignment.MiddleRight;

  1305             }

  1306         }

  1308         private void comboBoxDisplayType_SelectedIndexChanged(object sender, EventArgs e)

  1309         {

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

  1311             cds.DisplayType = comboBoxDisplayType.SelectedIndex;

  1312             Properties.Settings.Default.Save();

  1313             if (iDisplay.IsOpen())

  1314             {

  1315                 OpenDisplayConnection();

  1316             }

  1317             else

  1318             {

  1319                 UpdateStatus();

  1320             }

  1321         }

  1324         private void maskedTextBoxTimerInterval_TextChanged(object sender, EventArgs e)

  1325         {

  1326             if (maskedTextBoxTimerInterval.Text != "")

  1327             {

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

  1330                 if (interval > 0)

  1331                 {

  1332                     timer.Interval = interval;

  1333                     cds.TimerInterval = timer.Interval;

  1334                     Properties.Settings.Default.Save();

  1335                 }

  1336             }

  1337         }

  1339         private void buttonPowerOn_Click(object sender, EventArgs e)

  1340         {

  1341             iDisplay.PowerOn();

  1342         }

  1344         private void buttonPowerOff_Click(object sender, EventArgs e)

  1345         {

  1346             iDisplay.PowerOff();

  1347         }

  1349         private void buttonShowClock_Click(object sender, EventArgs e)

  1350         {

  1351             iDisplay.ShowClock();

  1352         }

  1354         private void buttonHideClock_Click(object sender, EventArgs e)

  1355         {

  1356             iDisplay.HideClock();

  1357         }

  1358     }

  1360     /// <summary>

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

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

  1363     /// </summary>

  1364     public class ClientData

  1365     {

  1366         public ClientData(string aSessionId, ICallback aCallback)

  1367         {

  1368             SessionId = aSessionId;

  1369             Name = "";

  1370             Fields = new List<DataField>();

  1371             Layout = new TableLayout(1, 2); //Default to one column and two rows

  1372             Callback = aCallback;

  1373         }

  1375         public string SessionId { get; set; }

  1376         public string Name { get; set; }

  1377         public List<DataField> Fields { get; set; }

  1378         public TableLayout Layout { get; set; }

  1379         public ICallback Callback { get; set; }

  1380     }

  1381 }

author	sl
	Sat, 25 Oct 2014 13:35:11 +0200
changeset 72	fd0bb39a7818
parent 70	dcd2bbb90d42
child 75	2549a8055bd1
permissions	-rw-r--r--