SharpDisplayManager: Server/MainForm.cs@2add30edb508

     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, TextField aTextField);

    29     public delegate void SetBitmapDelegate(string SessionId, BitmapField aTextField);

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

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

    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="aTextField"></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="aTextField"></param>

   806         public void SetClientTextThreadSafe(string aSessionId, TextField aTextField)

   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, aTextField });

   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 < (aTextField.Index + 1))

   822                     {

   823                         //Add a text field with proper index

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

   825                     }

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

   828                     //We are in the proper thread

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

   830                     {

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

   832                         label.Text = aTextField.Text;

   833                         label.TextAlign = aTextField.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<TextField> aTextFields)

   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, aTextFields });

   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                     int j = 0;

   867                     foreach (TextField textField in aTextFields)

   868                     {

   869                         if (client.Fields.Count < (j + 1))

   870                         {

   871                             client.Fields.Add(textField);

   872                         }

   873                         else

   874                         {

   875                             client.Fields[j] = textField;

   876                         }

   877                         j++;

   878                     }

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

   880                     foreach (TextField field in aTextFields)

   881                     {

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

   883                         {

   884                             //Proper control type just update the text

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

   886                             label.Text = field.Text;

   887                             label.TextAlign = field.Alignment;

   888                         }

   889                         else

   890                         {

   891                             //Wrong control for the given field

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

   893                             UpdateTableLayoutPanel(iCurrentClientData);

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

   895                         }

   896                     }

   899                     UpdateClientTreeViewNode(client);

   900                 }

   901             }

   902         }

   904         /// <summary>

   905         ///

   906         /// </summary>

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

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

   909         public void SetClientBitmapThreadSafe(string aSessionId, BitmapField aBitmapField)

   910         {

   911             if (this.InvokeRequired)

   912             {

   913                 //Not in the proper thread, invoke ourselves

   914                 SetBitmapDelegate d = new SetBitmapDelegate(SetClientBitmapThreadSafe);

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

   916             }

   917             else

   918             {

   919                 SetCurrentClient(aSessionId);

   920                 ClientData client = iClients[aSessionId];

   921                 if (client != null)

   922                 {

   923                     //Make sure all our texts are in place

   924                     while (client.Fields.Count < (aBitmapField.Index + 1))

   925                     {

   926                         //Add a text field with proper index

   927                         client.Fields.Add(new TextField(client.Fields.Count));

   928                     }

   930                     client.Fields[aBitmapField.Index] = aBitmapField;

   932                     //We are in the proper thread

   933                     if (tableLayoutPanel.Controls[aBitmapField.Index] is PictureBox)

   934                     {

   935                         PictureBox pictureBox = (PictureBox)tableLayoutPanel.Controls[aBitmapField.Index];

   936                         pictureBox.Image = aBitmapField.Bitmap;

   937                     }

   938                     else

   939                     {

   940                         //Wrong control type re-create them all

   941                         UpdateTableLayoutPanel(iCurrentClientData);

   942                     }

   943                     //

   944                     UpdateClientTreeViewNode(client);

   945                 }

   946             }

   947         }

   951         /// <summary>

   952         ///

   953         /// </summary>

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

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

   956         public void SetClientNameThreadSafe(string aSessionId, string aName)

   957         {

   958             if (this.InvokeRequired)

   959             {

   960                 //Not in the proper thread, invoke ourselves

   961                 SetClientNameDelegate d = new SetClientNameDelegate(SetClientNameThreadSafe);

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

   963             }

   964             else

   965             {

   966                 //We are in the proper thread

   967                 //Get our client

   968                 ClientData client = iClients[aSessionId];

   969                 if (client != null)

   970                 {

   971                     //Set its name

   972                     client.Name = aName;

   973                     //Update our tree-view

   974                     UpdateClientTreeViewNode(client);

   975                 }

   976             }

   977         }

   979         /// <summary>

   980         ///

   981         /// </summary>

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

   983         private void UpdateClientTreeViewNode(ClientData aClient)

   984         {

   985             if (aClient == null)

   986             {

   987                 return;

   988             }

   990             TreeNode node = null;

   991             //Check that our client node already exists

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

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

   994             if (nodes.Count()>0)

   995             {

   996                 //We already have a node for that client

   997                 node = nodes[0];

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

   999                 node.Nodes.Clear();

  1000             }

  1001             else

  1002             {

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

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

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

  1006             }

  1008             if (node != null)

  1009             {

  1010                 //Change its name

  1011                 if (aClient.Name != "")

  1012                 {

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

  1014                     node.Text = aClient.Name;

  1015                     //Add a child with SessionId

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

  1017                 }

  1018                 else

  1019                 {

  1020                     //No name, use session ID instead

  1021                     node.Text = aClient.SessionId;

  1022                 }

  1024                 if (aClient.Fields.Count > 0)

  1025                 {

  1026                     //Create root node for our texts

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

  1028                     node.Nodes.Add(textsRoot);

  1029                     //For each text add a new entry

  1030                     foreach (DataField field in aClient.Fields)

  1031                     {

  1032                         if (field is TextField)

  1033                         {

  1034                             TextField textField = (TextField)field;

  1035                             textsRoot.Nodes.Add(new TreeNode(textField.Text));

  1036                         }

  1037                         else if (field is BitmapField)

  1038                         {

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

  1040                         }

  1041                         else

  1042                         {

  1043                             textsRoot.Nodes.Add(new TreeNode("[Unknown Field Type]"));

  1044                         }

  1045                     }

  1046                 }

  1048                 node.ExpandAll();

  1049             }

  1050         }

  1052         private void buttonAddRow_Click(object sender, EventArgs e)

  1053         {

  1054             if (tableLayoutPanel.RowCount < 6)

  1055             {

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

  1057             }

  1058         }

  1060         private void buttonRemoveRow_Click(object sender, EventArgs e)

  1061         {

  1062             if (tableLayoutPanel.RowCount > 1)

  1063             {

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

  1065             }

  1067             UpdateTableLayoutRowStyles();

  1068         }

  1070         private void buttonAddColumn_Click(object sender, EventArgs e)

  1071         {

  1072             if (tableLayoutPanel.ColumnCount < 8)

  1073             {

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

  1075             }

  1076         }

  1078         private void buttonRemoveColumn_Click(object sender, EventArgs e)

  1079         {

  1080             if (tableLayoutPanel.ColumnCount > 1)

  1081             {

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

  1083             }

  1084         }

  1087         /// <summary>

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

  1089         /// </summary>

  1090         private void UpdateTableLayoutRowStyles()

  1091         {

  1092             foreach (RowStyle rowStyle in tableLayoutPanel.RowStyles)

  1093             {

  1094                 rowStyle.SizeType = SizeType.Percent;

  1095                 rowStyle.Height = 100 / tableLayoutPanel.RowCount;

  1096             }

  1097         }

  1099         /// <summary>

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

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

  1102         /// </summary>

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

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

  1105         private void UpdateTableLayoutPanel(int aColumn, int aRow)

  1106         {

  1107             tableLayoutPanel.Controls.Clear();

  1108             tableLayoutPanel.RowStyles.Clear();

  1109             tableLayoutPanel.ColumnStyles.Clear();

  1110             tableLayoutPanel.RowCount = 0;

  1111             tableLayoutPanel.ColumnCount = 0;

  1113             while (tableLayoutPanel.RowCount < aRow)

  1114             {

  1115                 tableLayoutPanel.RowCount++;

  1116             }

  1118             while (tableLayoutPanel.ColumnCount < aColumn)

  1119             {

  1120                 tableLayoutPanel.ColumnCount++;

  1121             }

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

  1124             {

  1125                 //Create our column styles

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

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

  1129                 {

  1130                     if (i == 0)

  1131                     {

  1132                         //Create our row styles

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

  1134                     }

  1136                     MarqueeLabel control = new SharpDisplayManager.MarqueeLabel();

  1137                     control.AutoEllipsis = true;

  1138                     control.AutoSize = true;

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

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

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

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

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

  1144                     control.OwnTimer = false;

  1145                     control.PixelsPerSecond = 64;

  1146                     control.Separator = "|";

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

  1148                     //control.TabIndex = 2;

  1149                     control.Font = cds.Font;

  1150                     control.Text = "ABCDEFGHIJKLMNOPQRST-0123456789";

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

  1152                     control.UseCompatibleTextRendering = true;

  1153                     //

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

  1155                 }

  1156             }

  1158             CheckFontHeight();

  1159         }

  1162         /// <summary>

  1163         /// Update our display table layout.

  1164         /// </summary>

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

  1166         private void UpdateTableLayoutPanel(ClientData aClient)

  1167         {

  1168             TableLayout layout = aClient.Layout;

  1170             tableLayoutPanel.Controls.Clear();

  1171             tableLayoutPanel.RowStyles.Clear();

  1172             tableLayoutPanel.ColumnStyles.Clear();

  1173             tableLayoutPanel.RowCount = 0;

  1174             tableLayoutPanel.ColumnCount = 0;

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

  1177             {

  1178                 tableLayoutPanel.RowCount++;

  1179             }

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

  1182             {

  1183                 tableLayoutPanel.ColumnCount++;

  1184             }

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

  1187             {

  1188                 //Create our column styles

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

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

  1192                 {

  1193                     if (i == 0)

  1194                     {

  1195                         //Create our row styles

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

  1197                     }

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

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

  1201                     {

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

  1203                         aClient.Fields.Add(new TextField(aClient.Fields.Count));

  1204                     }

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

  1207                     Control control = CreateControlForDataField(aClient.Fields[tableLayoutPanel.Controls.Count]);

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

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

  1210                 }

  1211             }

  1213             CheckFontHeight();

  1214         }

  1216         /// <summary>

  1217         /// Not used yet.

  1218         /// </summary>

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

  1220         private Control CreateControlForDataField(DataField aField)

  1221         {

  1222             Control control=null;

  1223             if (aField is TextField)

  1224             {

  1225                 MarqueeLabel label = new SharpDisplayManager.MarqueeLabel();

  1226                 label.AutoEllipsis = true;

  1227                 label.AutoSize = true;

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

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

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

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

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

  1233                 label.OwnTimer = false;

  1234                 label.PixelsPerSecond = 64;

  1235                 label.Separator = "|";

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

  1237                 //control.TabIndex = 2;

  1238                 label.Font = cds.Font;

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

  1241                 label.UseCompatibleTextRendering = true;

  1242                 TextField textField = (TextField)aField;

  1243                 label.Text = textField.Text;

  1244                 //

  1245                 control = label;

  1246             }

  1247             else if (aField is BitmapField)

  1248             {

  1249                 //Create picture box

  1250                 PictureBox picture = new PictureBox();

  1251                 picture.AutoSize = true;

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

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

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

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

  1256                 picture.Name = "pictureBox" + aField;

  1257                 //Set our image

  1258                 BitmapField bitmapField = (BitmapField)aField;

  1259                 picture.Image = bitmapField.Bitmap;

  1260                 //

  1261                 control = picture;

  1262             }

  1264             return control;

  1265         }

  1268         private void buttonAlignLeft_Click(object sender, EventArgs e)

  1269         {

  1270             foreach (MarqueeLabel ctrl in tableLayoutPanel.Controls)

  1271             {

  1272                 ctrl.TextAlign = ContentAlignment.MiddleLeft;

  1273             }

  1274         }

  1276         private void buttonAlignCenter_Click(object sender, EventArgs e)

  1277         {

  1278             foreach (MarqueeLabel ctrl in tableLayoutPanel.Controls)

  1279             {

  1280                 ctrl.TextAlign = ContentAlignment.MiddleCenter;

  1281             }

  1282         }

  1284         private void buttonAlignRight_Click(object sender, EventArgs e)

  1285         {

  1286             foreach (MarqueeLabel ctrl in tableLayoutPanel.Controls)

  1287             {

  1288                 ctrl.TextAlign = ContentAlignment.MiddleRight;

  1289             }

  1290         }

  1292         private void comboBoxDisplayType_SelectedIndexChanged(object sender, EventArgs e)

  1293         {

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

  1295             cds.DisplayType = comboBoxDisplayType.SelectedIndex;

  1296             Properties.Settings.Default.Save();

  1297             if (iDisplay.IsOpen())

  1298             {

  1299                 OpenDisplayConnection();

  1300             }

  1301             else

  1302             {

  1303                 UpdateStatus();

  1304             }

  1305         }

  1308         private void maskedTextBoxTimerInterval_TextChanged(object sender, EventArgs e)

  1309         {

  1310             if (maskedTextBoxTimerInterval.Text != "")

  1311             {

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

  1314                 if (interval > 0)

  1315                 {

  1316                     timer.Interval = interval;

  1317                     cds.TimerInterval = timer.Interval;

  1318                     Properties.Settings.Default.Save();

  1319                 }

  1320             }

  1321         }

  1323         private void buttonPowerOn_Click(object sender, EventArgs e)

  1324         {

  1325             iDisplay.PowerOn();

  1326         }

  1328         private void buttonPowerOff_Click(object sender, EventArgs e)

  1329         {

  1330             iDisplay.PowerOff();

  1331         }

  1333         private void buttonShowClock_Click(object sender, EventArgs e)

  1334         {

  1335             iDisplay.ShowClock();

  1336         }

  1338         private void buttonHideClock_Click(object sender, EventArgs e)

  1339         {

  1340             iDisplay.HideClock();

  1341         }

  1342     }

  1344     /// <summary>

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

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

  1347     /// </summary>

  1348     public class ClientData

  1349     {

  1350         public ClientData(string aSessionId, ICallback aCallback)

  1351         {

  1352             SessionId = aSessionId;

  1353             Name = "";

  1354             Fields = new List<DataField>();

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

  1356             Callback = aCallback;

  1357         }

  1359         public string SessionId { get; set; }

  1360         public string Name { get; set; }

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

  1362         public TableLayout Layout { get; set; }

  1363         public ICallback Callback { get; set; }

  1364     }

  1365 }

author	sl
	Mon, 13 Oct 2014 21:42:42 +0200
changeset 69	2add30edb508
parent 68	1d0cd5e6e0a9
child 70	dcd2bbb90d42
permissions	-rw-r--r--