SharpDisplayManager: Server/MainForm.cs@f444344fc205

     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                     foreach (TextField textField in aTextFields)

   867                     {

   868                         //Make sure all our texts are in place

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

   870                         {

   871                             //Add a text field with proper index

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

   873                         }

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

   875                     }

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

   877                     foreach (TextField field in aTextFields)

   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                     }

   896                     UpdateClientTreeViewNode(client);

   897                 }

   898             }

   899         }

   901         /// <summary>

   902         ///

   903         /// </summary>

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

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

   906         public void SetClientBitmapThreadSafe(string aSessionId, BitmapField aBitmapField)

   907         {

   908             if (this.InvokeRequired)

   909             {

   910                 //Not in the proper thread, invoke ourselves

   911                 SetBitmapDelegate d = new SetBitmapDelegate(SetClientBitmapThreadSafe);

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

   913             }

   914             else

   915             {

   916                 SetCurrentClient(aSessionId);

   917                 ClientData client = iClients[aSessionId];

   918                 if (client != null)

   919                 {

   920                     //Make sure all our texts are in place

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

   922                     {

   923                         //Add a text field with proper index

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

   925                     }

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

   929                     //We are in the proper thread

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

   931                     {

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

   933                         pictureBox.Image = aBitmapField.Bitmap;

   934                     }

   935                     else

   936                     {

   937                         //Wrong control type re-create them all

   938                         UpdateTableLayoutPanel(iCurrentClientData);

   939                     }

   940                     //

   941                     UpdateClientTreeViewNode(client);

   942                 }

   943             }

   944         }

   948         /// <summary>

   949         ///

   950         /// </summary>

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

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

   953         public void SetClientNameThreadSafe(string aSessionId, string aName)

   954         {

   955             if (this.InvokeRequired)

   956             {

   957                 //Not in the proper thread, invoke ourselves

   958                 SetClientNameDelegate d = new SetClientNameDelegate(SetClientNameThreadSafe);

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

   960             }

   961             else

   962             {

   963                 //We are in the proper thread

   964                 //Get our client

   965                 ClientData client = iClients[aSessionId];

   966                 if (client != null)

   967                 {

   968                     //Set its name

   969                     client.Name = aName;

   970                     //Update our tree-view

   971                     UpdateClientTreeViewNode(client);

   972                 }

   973             }

   974         }

   976         /// <summary>

   977         ///

   978         /// </summary>

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

   980         private void UpdateClientTreeViewNode(ClientData aClient)

   981         {

   982             if (aClient == null)

   983             {

   984                 return;

   985             }

   987             TreeNode node = null;

   988             //Check that our client node already exists

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

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

   991             if (nodes.Count()>0)

   992             {

   993                 //We already have a node for that client

   994                 node = nodes[0];

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

   996                 node.Nodes.Clear();

   997             }

   998             else

   999             {

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

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

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

  1003             }

  1005             if (node != null)

  1006             {

  1007                 //Change its name

  1008                 if (aClient.Name != "")

  1009                 {

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

  1011                     node.Text = aClient.Name;

  1012                     //Add a child with SessionId

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

  1014                 }

  1015                 else

  1016                 {

  1017                     //No name, use session ID instead

  1018                     node.Text = aClient.SessionId;

  1019                 }

  1021                 if (aClient.Fields.Count > 0)

  1022                 {

  1023                     //Create root node for our texts

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

  1025                     node.Nodes.Add(textsRoot);

  1026                     //For each text add a new entry

  1027                     foreach (DataField field in aClient.Fields)

  1028                     {

  1029                         if (field is TextField)

  1030                         {

  1031                             TextField textField = (TextField)field;

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

  1033                         }

  1034                         else if (field is BitmapField)

  1035                         {

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

  1037                         }

  1038                         else

  1039                         {

  1040                             textsRoot.Nodes.Add(new TreeNode("[Unknown]"));

  1041                         }

  1042                     }

  1043                 }

  1045                 node.ExpandAll();

  1046             }

  1047         }

  1049         private void buttonAddRow_Click(object sender, EventArgs e)

  1050         {

  1051             if (tableLayoutPanel.RowCount < 6)

  1052             {

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

  1054             }

  1055         }

  1057         private void buttonRemoveRow_Click(object sender, EventArgs e)

  1058         {

  1059             if (tableLayoutPanel.RowCount > 1)

  1060             {

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

  1062             }

  1064             UpdateTableLayoutRowStyles();

  1065         }

  1067         private void buttonAddColumn_Click(object sender, EventArgs e)

  1068         {

  1069             if (tableLayoutPanel.ColumnCount < 8)

  1070             {

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

  1072             }

  1073         }

  1075         private void buttonRemoveColumn_Click(object sender, EventArgs e)

  1076         {

  1077             if (tableLayoutPanel.ColumnCount > 1)

  1078             {

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

  1080             }

  1081         }

  1084         /// <summary>

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

  1086         /// </summary>

  1087         private void UpdateTableLayoutRowStyles()

  1088         {

  1089             foreach (RowStyle rowStyle in tableLayoutPanel.RowStyles)

  1090             {

  1091                 rowStyle.SizeType = SizeType.Percent;

  1092                 rowStyle.Height = 100 / tableLayoutPanel.RowCount;

  1093             }

  1094         }

  1096         /// DEPRECATED

  1097         /// <summary>

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

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

  1100         /// </summary>

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

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

  1103         private void UpdateTableLayoutPanel(int aColumn, int aRow)

  1104         {

  1105             tableLayoutPanel.Controls.Clear();

  1106             tableLayoutPanel.RowStyles.Clear();

  1107             tableLayoutPanel.ColumnStyles.Clear();

  1108             tableLayoutPanel.RowCount = 0;

  1109             tableLayoutPanel.ColumnCount = 0;

  1111             while (tableLayoutPanel.RowCount < aRow)

  1112             {

  1113                 tableLayoutPanel.RowCount++;

  1114             }

  1116             while (tableLayoutPanel.ColumnCount < aColumn)

  1117             {

  1118                 tableLayoutPanel.ColumnCount++;

  1119             }

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

  1122             {

  1123                 //Create our column styles

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

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

  1127                 {

  1128                     if (i == 0)

  1129                     {

  1130                         //Create our row styles

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

  1132                     }

  1134                     MarqueeLabel control = new SharpDisplayManager.MarqueeLabel();

  1135                     control.AutoEllipsis = true;

  1136                     control.AutoSize = true;

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

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

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

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

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

  1142                     control.OwnTimer = false;

  1143                     control.PixelsPerSecond = 64;

  1144                     control.Separator = "|";

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

  1146                     //control.TabIndex = 2;

  1147                     control.Font = cds.Font;

  1148                     control.Text = "ABCDEFGHIJKLMNOPQRST-0123456789";

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

  1150                     control.UseCompatibleTextRendering = true;

  1151                     //

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

  1153                 }

  1154             }

  1156             CheckFontHeight();

  1157         }

  1160         /// <summary>

  1161         /// Update our display table layout.

  1162         /// </summary>

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

  1164         private void UpdateTableLayoutPanel(ClientData aClient)

  1165         {

  1166             TableLayout layout = aClient.Layout;

  1167             int fieldCount = 0;

  1169             tableLayoutPanel.Controls.Clear();

  1170             tableLayoutPanel.RowStyles.Clear();

  1171             tableLayoutPanel.ColumnStyles.Clear();

  1172             tableLayoutPanel.RowCount = 0;

  1173             tableLayoutPanel.ColumnCount = 0;

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

  1176             {

  1177                 tableLayoutPanel.RowCount++;

  1178             }

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

  1181             {

  1182                 tableLayoutPanel.ColumnCount++;

  1183             }

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

  1186             {

  1187                 //Create our column styles

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

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

  1191                 {

  1192                     if (i == 0)

  1193                     {

  1194                         //Create our row styles

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

  1196                     }

  1198                     //Check if we already have a control

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

  1200                     if (existingControl!=null)

  1201                     {

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

  1203                         //Move on to next cell then

  1204                         continue;

  1205                     }

  1207                     fieldCount++;

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

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

  1211                     {

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

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

  1214                     }

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

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

  1218                     Control control = CreateControlForDataField(field);

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

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

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

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

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

  1225                 }

  1226             }

  1228             //

  1229             while (aClient.Fields.Count > fieldCount)

  1230             {

  1231                 //We have too much fields for this layout

  1232                 //Just discard them until we get there

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

  1234             }

  1236             CheckFontHeight();

  1237         }

  1239         /// <summary>

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

  1241         /// </summary>

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

  1243         private Control CreateControlForDataField(DataField aField)

  1244         {

  1245             Control control=null;

  1246             if (aField is TextField)

  1247             {

  1248                 MarqueeLabel label = new SharpDisplayManager.MarqueeLabel();

  1249                 label.AutoEllipsis = true;

  1250                 label.AutoSize = true;

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

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

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

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

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

  1256                 label.OwnTimer = false;

  1257                 label.PixelsPerSecond = 64;

  1258                 label.Separator = "|";

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

  1260                 //control.TabIndex = 2;

  1261                 label.Font = cds.Font;

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

  1264                 label.UseCompatibleTextRendering = true;

  1265                 TextField textField = (TextField)aField;

  1266                 label.Text = textField.Text;

  1267                 //

  1268                 control = label;

  1269             }

  1270             else if (aField is BitmapField)

  1271             {

  1272                 //Create picture box

  1273                 PictureBox picture = new PictureBox();

  1274                 picture.AutoSize = true;

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

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

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

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

  1279                 picture.Name = "pictureBox" + aField;

  1280                 //Set our image

  1281                 BitmapField bitmapField = (BitmapField)aField;

  1282                 picture.Image = bitmapField.Bitmap;

  1283                 //

  1284                 control = picture;

  1285             }

  1287             return control;

  1288         }

  1291         private void buttonAlignLeft_Click(object sender, EventArgs e)

  1292         {

  1293             foreach (MarqueeLabel ctrl in tableLayoutPanel.Controls)

  1294             {

  1295                 ctrl.TextAlign = ContentAlignment.MiddleLeft;

  1296             }

  1297         }

  1299         private void buttonAlignCenter_Click(object sender, EventArgs e)

  1300         {

  1301             foreach (MarqueeLabel ctrl in tableLayoutPanel.Controls)

  1302             {

  1303                 ctrl.TextAlign = ContentAlignment.MiddleCenter;

  1304             }

  1305         }

  1307         private void buttonAlignRight_Click(object sender, EventArgs e)

  1308         {

  1309             foreach (MarqueeLabel ctrl in tableLayoutPanel.Controls)

  1310             {

  1311                 ctrl.TextAlign = ContentAlignment.MiddleRight;

  1312             }

  1313         }

  1315         private void comboBoxDisplayType_SelectedIndexChanged(object sender, EventArgs e)

  1316         {

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

  1318             cds.DisplayType = comboBoxDisplayType.SelectedIndex;

  1319             Properties.Settings.Default.Save();

  1320             if (iDisplay.IsOpen())

  1321             {

  1322                 OpenDisplayConnection();

  1323             }

  1324             else

  1325             {

  1326                 UpdateStatus();

  1327             }

  1328         }

  1331         private void maskedTextBoxTimerInterval_TextChanged(object sender, EventArgs e)

  1332         {

  1333             if (maskedTextBoxTimerInterval.Text != "")

  1334             {

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

  1337                 if (interval > 0)

  1338                 {

  1339                     timer.Interval = interval;

  1340                     cds.TimerInterval = timer.Interval;

  1341                     Properties.Settings.Default.Save();

  1342                 }

  1343             }

  1344         }

  1346         private void buttonPowerOn_Click(object sender, EventArgs e)

  1347         {

  1348             iDisplay.PowerOn();

  1349         }

  1351         private void buttonPowerOff_Click(object sender, EventArgs e)

  1352         {

  1353             iDisplay.PowerOff();

  1354         }

  1356         private void buttonShowClock_Click(object sender, EventArgs e)

  1357         {

  1358             iDisplay.ShowClock();

  1359         }

  1361         private void buttonHideClock_Click(object sender, EventArgs e)

  1362         {

  1363             iDisplay.HideClock();

  1364         }

  1365     }

  1367     /// <summary>

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

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

  1370     /// </summary>

  1371     public class ClientData

  1372     {

  1373         public ClientData(string aSessionId, ICallback aCallback)

  1374         {

  1375             SessionId = aSessionId;

  1376             Name = "";

  1377             Fields = new List<DataField>();

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

  1379             Callback = aCallback;

  1380         }

  1382         public string SessionId { get; set; }

  1383         public string Name { get; set; }

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

  1385         public TableLayout Layout { get; set; }

  1386         public ICallback Callback { get; set; }

  1387     }

  1388 }

author	sl
	Wed, 22 Oct 2014 12:17:52 +0200
changeset 71	f444344fc205
parent 69	2add30edb508
child 72	fd0bb39a7818
permissions	-rw-r--r--