From 3fe2d423eb3f78da577e273d03013a4cc42eea8d Mon Sep 17 00:00:00 2001 From: manu Date: Sun, 4 May 2014 17:57:34 +0000 Subject: [PATCH] Ajout Driver Arduino Micro --- DMX-2.0/DMX-2.0.csproj | 3 + DMX-2.0/DriverBoitierV3.cs | 593 ++++++++++++++++++++++ DMX-2.0/DriverBoitierV3UI.cs | 113 +++++ DMX-2.0/GestionDriversUI.cs | 7 + DMX-2.0/gtk-gui/DMX2.DriverBoitierV3UI.cs | 204 ++++++++ DMX-2.0/gtk-gui/gui.stetic | 303 +++++++++++ 6 files changed, 1223 insertions(+) create mode 100644 DMX-2.0/DriverBoitierV3.cs create mode 100644 DMX-2.0/DriverBoitierV3UI.cs create mode 100644 DMX-2.0/gtk-gui/DMX2.DriverBoitierV3UI.cs diff --git a/DMX-2.0/DMX-2.0.csproj b/DMX-2.0/DMX-2.0.csproj index fb543f8..0ccdb57 100644 --- a/DMX-2.0/DMX-2.0.csproj +++ b/DMX-2.0/DMX-2.0.csproj @@ -151,6 +151,9 @@ + + + diff --git a/DMX-2.0/DriverBoitierV3.cs b/DMX-2.0/DriverBoitierV3.cs new file mode 100644 index 0000000..32fd84d --- /dev/null +++ b/DMX-2.0/DriverBoitierV3.cs @@ -0,0 +1,593 @@ +/* + + Copyright (C) Arnaud Houdelette 2012-2014 + Copyright (C) Emmanuel Langlois 2012-2014 + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + +using System; +using System.Threading; +using System.IO.Ports; +using System.Xml; +using System.Collections.Generic; + +namespace DMX2 +{ + public class DriverBoitierV3 : DriverDMX, IEventProvider + { + + struct dmxState { + public dmxState(int _dmx, byte _value){ + value=_value; dmx=_dmx; + } + public int dmx; + public byte value; + } + + enum etatAutomate { + Deconnecte, + Transmission, + Erreur, + Fin + } + + const int timeout = 200; + + // tampons Entrée/Sortie + public byte[] inputbuffer = new byte[516]; + byte[] outputbuffer = new byte[514]; + + //Thread de boucle + Thread loopthread=null; + + public UniversDMX patch1=null; + + + string portname = ""; + SerialPort serial = null; + + + int brk = 150; + int mab = 50; + int nbc1 = 512; + byte flag_merge1 = 1; + + + bool reinit=false ; + + + + public void ReInit () { + reinit=true; + } + + public int Break { + get { + return brk; + } + } + + public int Mab { + get { + return mab; + } + } + + public byte Flag_merge1 { + get { + return flag_merge1; + } + } + + + public DriverBoitierV3 (string serialport, string id): base(id) + { + portname = serialport; + outputbuffer[0]=27; + outputbuffer[1]=68; + Start(); + + } + + bool paramFlag = false; + + public void SetBreak( int _brk, int _mab, byte _merge1) + { + brk = _brk; + mab = _mab; + flag_merge1 = _merge1; + paramFlag = true; + } + + void Start () + { + if (loopthread == null) { + loopthread = new Thread(new ThreadStart(MainLoop)); + loopthread.Start(); + } + } + + void Connection () + { + Console.WriteLine ("DriverV3.Connection()"); + if (serial != null) { + serial.Close (); + serial.Dispose (); + serial = null; + } + if (!System.IO.File.Exists (portname)) { + Thread.Sleep (200); + return; + } + serial = new SerialPort (portname);//, 9600, Parity.None, 8, StopBits.One); + Console.WriteLine (portname); + //serial.DtrEnable = false; + //serial.ReadTimeout = 200; + //serial.WriteTimeout = 200; + try { + serial.Open (); + serial.RtsEnable = true; + serial.DtrEnable = true; + Attente(DateTime.Now.AddMilliseconds(2000)); + + if(Synchronisation()) + etat = etatAutomate.Transmission; + else { + serial.Close(); + etat = etatAutomate.Deconnecte; + } + + } catch (Exception ex) { + etat = etatAutomate.Deconnecte; + Console.WriteLine("DriverV3:Connection : {0}",ex); + Thread.Sleep (500); + } + } + + /// + /// Synchronise le pilote et le boitier ... + /// Après connexion ou erreur + /// + bool Synchronisation () + { + //return true; + Console.WriteLine ("DriverV3.Synchronisation()"); + + if (serial == null) + return false; + if (!serial.IsOpen) + return false; + + // Au cas ou le boitier attends une fin de commande : envoi 1030 octets a 0 (le boitier ignorera tout seul la suite) + byte[] tmpBuffer = new byte[530]; + serial.Write (tmpBuffer, 0, 530); + + // On attends un peu + Thread.Sleep (300); + + // Vide le buffer d'entree + if (serial.BytesToRead > 0) + serial.ReadExisting (); + + if(serial.BytesToWrite > 0) + Console.WriteLine("Les infos partent pas ..."); + + // on envoie Esc 'A' + tmpBuffer [0] = 27; + tmpBuffer [1] = 65; + serial.Write (tmpBuffer, 0, 2); + + // On attends un peu + if(!WaitForData (1)) { + return false; + } + paramFlag = true; + serial.Read(tmpBuffer,0,1); + if(tmpBuffer[0] == 65) return true; + return false; + } + + volatile etatAutomate etat = etatAutomate.Deconnecte; + DateTime finAttente = DateTime.Now; + int compteErreur = 0; + + void MainLoop () + { + //DateTime t = DateTime.Now; + while (etat != etatAutomate.Fin) { + try { + switch (etat) { + case etatAutomate.Deconnecte: + Connection (); + compteErreur = 0; + break; + case etatAutomate.Transmission: + finAttente = DateTime.Now.AddMilliseconds (22); + //Console.WriteLine(DateTime.Now-t); + //t = DateTime.Now; + EnvoiTrame (); + Reception (); + Attente (finAttente); + if (paramFlag) + Parametrage (); + if (reinit) + EnvoieReInit(); + break; + case etatAutomate.Erreur: + Console.WriteLine("DriverV3 : etatAutomate.Erreur"); + compteErreur ++; + Deconnecte (); + Attente (DateTime.Now.AddSeconds (2)); + break; +// case etatAutomate.Parametrage: +// EnvoiParam(); +// break; +// case etatAutomate.Reset: +// EnvoiReset(); +// break; + } + } catch (Exception ex) { + Console.WriteLine("Exception dans DriverV3 : {0}",ex); + if(etat != etatAutomate.Fin) etat = etatAutomate.Erreur; + } + } + Deconnecte(); + } + + void Attente (DateTime date) + { + int sleeptime = (int) (date - DateTime.Now).TotalMilliseconds-1; + if(sleeptime>2) + Thread.Sleep(sleeptime); + + while (DateTime.Now 0) + Thread.Sleep(1); + + serial.Write(outputbuffer,0,outputbuffer.Length); + } catch (Exception ex) { + Console.WriteLine("Exception Envoi {0}",ex); + etat = etatAutomate.Erreur; + } + } + + bool WaitForData (int len) + { + int wcnt =0 ; + + while (serial.BytesToRead < len) { + Thread.Sleep (1); + if (++wcnt > timeout) + return false; + } + return true; + } +// void EnvoiParam () +// { +// throw new NotImplementedException (); +// } +// +// void EnvoiReset () +// { +// throw new NotImplementedException (); +// } + byte flag_input; + void Reception () + { + try { + + + if(!serial.IsOpen || etat == etatAutomate.Erreur) { + etat = etatAutomate.Erreur; + return; + } + + if(!WaitForData (inputbuffer.Length)) { + etat = etatAutomate.Erreur; + Console.WriteLine("DriverV3.Reception : attente depassee"); + return ; + } + + serial.Read(inputbuffer,0,inputbuffer.Length); + if (flag_input != inputbuffer[0]) { + flag_input = inputbuffer[0]; + Console.WriteLine(flag_input ); + } + if(serial.BytesToRead>0) + serial.ReadExisting (); + + ProcessData(); + + compteErreur= 0; + } catch (Exception ex) { + Console.WriteLine(serial.BytesToRead); + Console.WriteLine("Exception Reception {0}",ex); + etat = etatAutomate.Erreur; + } + } + + void Parametrage () + { + paramFlag = false; + + if (!serial.IsOpen) { + etat = etatAutomate.Erreur; + return; + } + + byte[] tmpBuffer = new byte[6]; + + tmpBuffer [0] = 27; // Esc + tmpBuffer [1] = 66; // 'B' + + tmpBuffer [2] = // nb circuits + (byte)(nbc1 / 2 - 1); + + tmpBuffer [3] = (byte)brk; + tmpBuffer [4] = (byte)mab; + + tmpBuffer [5] = (byte) (flag_merge1 ); + + serial.Write (tmpBuffer, 0, tmpBuffer.Length); + + if(!WaitForData (1)) { + etat = etatAutomate.Erreur; + return ; + } + + serial.Read(tmpBuffer,0,1); + if(tmpBuffer[0] != 66) + etat = etatAutomate.Erreur; + + } + + void EnvoieReInit() + { + reinit = false; + + if (!serial.IsOpen) { + etat = etatAutomate.Erreur; + return; + } + + byte[] tmpBuffer = new byte[2]; + + tmpBuffer [0] = 27; // Esc + tmpBuffer [1] = 67; // 'B' + + serial.Write (tmpBuffer, 0, tmpBuffer.Length); + + if(!WaitForData (1)) { + etat = etatAutomate.Erreur; + return ; + } + + serial.Read(tmpBuffer,0,1); + if(tmpBuffer[0] != 67) + etat = etatAutomate.Erreur; + } + + void ProcessData () + { + lock(watchdmx) + foreach (int dmx in watchdmx) { + if( inputbuffer[dmx-1]!= lastVal[dmx]){ + lastVal[dmx] = inputbuffer[dmx-1]; + eventsPending.Enqueue(new dmxState(dmx,inputbuffer[dmx-1])); + } + } + } + + public override void Dispose () + { + disposed = true; + etat = etatAutomate.Fin; + if (loopthread != null) { + loopthread.Join (); + loopthread = null; + } + //TODO : Close Port + if(serial != null) + serial.Dispose(); + + } + #region implemented abstract members of DMX2.DriverDMX + public override Gtk.Widget GetUI () + { + return new DriverBoitierV3UI(this); + } + #endregion + + + + #region IEventProvider implementation + + List watchdmx = new List(); + Dictionary lastVal = new Dictionary(); + + static System.Text.RegularExpressions.Regex regexEventID = new System.Text.RegularExpressions.Regex( + @"BV2-D(?\d+)?", + System.Text.RegularExpressions.RegexOptions.Compiled); + + System.Collections.Concurrent.ConcurrentQueue eventsPending = + new System.Collections.Concurrent.ConcurrentQueue(); + + bool IEventProvider.Bind (string eventId) + { + var res = regexEventID.Match (eventId); + if (res.Success) { + int dmx = int.Parse (res.Groups ["dmx"].Value); + if(dmx<0||dmx>511) return false; + lock(watchdmx){ + if(!watchdmx.Contains(dmx)) + { + watchdmx.Add(dmx); + lastVal[dmx] = 0; + } + } + return true; + } + return false; + } + + void IEventProvider.Unbind (string eventId) + { + var res = regexEventID.Match (eventId); + if (res.Success) { + int dmx = int.Parse (res.Groups ["dmx"].Value); + if(dmx<1||dmx>512) return; + lock(watchdmx) watchdmx.Remove (dmx); + return; + } + return; + } + + Gtk.Menu IEventProvider.GetProviderSubMenu (EventManager.EventMenuData state, Gtk.ButtonPressEventHandler handler) + { + Gtk.Menu retmenu = new Gtk.Menu (); + + Gtk.MenuItem evmenuitem = new Gtk.MenuItem ("Entrée DMX"); + retmenu.Add (evmenuitem); + Gtk.Menu evmenu = new Gtk.Menu (); + evmenuitem.Submenu = evmenu; + + for (int c = 0; c<512; c+=100) { + Gtk.MenuItem citem = new Gtk.MenuItem(string.Format("De {0} à {1}", c==0?1:c, c==500?512:c+99 )); + Gtk.Menu cmenu = new Gtk.Menu(); + citem.Submenu = cmenu; + evmenu.Add(citem); + + for(int d=0 ; d<100;d+=10){ + if(c+d>512) break; + Gtk.MenuItem ditem = new Gtk.MenuItem(string.Format("De {0} à {1}", c+d==0?1:c+d, c+d==510?512:c+d+9 )); + Gtk.Menu dmenu = new Gtk.Menu(); + ditem.Submenu = dmenu; + cmenu.Add(ditem); + + for(int u=0; u<10;u++){ + if(c+d+u==0) continue; + if(c+d+u>512) break; + Gtk.MenuItem uitem = new Gtk.MenuItem(string.Format("Entrée DMX {0}",c+d+u)); + uitem.Data[EventManager.EventIdKey] = string.Format("BV2-D{0}",c+d+u); + uitem.Data[EventManager.StateKey] = state; + uitem.ButtonPressEvent += handler; + dmenu.Add (uitem); + + } + } + } + + return retmenu; + } + + void IEventProvider.ProcessEvents (EventManagerCallback callback) + { + dmxState dmxs; + EventData evd; + while (eventsPending.TryDequeue(out dmxs)) { + evd.id= string.Format("BV2-D{0}",dmxs.dmx ); + evd.value = dmxs.value; + callback(evd); + } + } + + string IEventProvider.MenuName { + get { + return "Boitier V2"; + } + } + #endregion + + #region implemented abstract members of DMX2.DriverDMX + public override void Save (System.Xml.XmlElement parent) + { + System.Xml.XmlElement el = parent.OwnerDocument.CreateElement ("DriverBoitierV3"); + + parent.AppendChild (el); + + el.SetAttribute ("portname", portname.ToString ()); + el.SetAttribute ("id", ID); + + if(patch1!=null) el.SetAttribute ("univers1", patch1.Nom); + + + el.SetAttribute("mab",mab.ToString()); + el.SetAttribute("brk",brk.ToString()); + el.SetAttribute("merge1",(flag_merge1!=0).ToString()); + + + } + #endregion + + public static new DriverDMX Load(Conduite conduite, XmlElement el) { + //System.Xml.XmlElement xmlE; + + string port = el.GetAttribute("portname"); + + if(! System.IO.File.Exists(port)) return null; + + string id = el.GetAttribute("id"); + + DriverBoitierV3 drv = new DriverBoitierV3(port,id); + + if(el.HasAttribute("univers1")) + { + string univ = el.GetAttribute("univers1"); + foreach (UniversDMX u in conduite.Patches){ + if(u.Nom== univ){ + drv.patch1 = u; + break; + } + } + } + + + int mab,brk; + byte merge1; + + mab = int.Parse(el.TryGetAttribute("mab","150")); + brk = int.Parse(el.TryGetAttribute("brk","50")); + merge1 = (byte)( bool.Parse(el.TryGetAttribute("merge1","True"))?1:0 ); + + + drv.SetBreak(brk,mab,merge1); + + return drv; + } + + } +} + diff --git a/DMX-2.0/DriverBoitierV3UI.cs b/DMX-2.0/DriverBoitierV3UI.cs new file mode 100644 index 0000000..5384c0e --- /dev/null +++ b/DMX-2.0/DriverBoitierV3UI.cs @@ -0,0 +1,113 @@ +/* + + Copyright (C) Arnaud Houdelette 2012-2014 + Copyright (C) Emmanuel Langlois 2012-2014 + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + +using System; +using System.Collections.Generic; +using Gtk; +using System.IO; + +namespace DMX2 +{ + [System.ComponentModel.ToolboxItem(true)] + public partial class DriverBoitierV3UI : Gtk.Bin + { + DriverBoitierV3 drv; + public DriverBoitierV3UI (DriverBoitierV3 _drv) + { + drv = _drv; + this.Build (); + ConstruitCBUnivers(); + } + + ListStore lsCbUnivers1 = new ListStore(typeof(UniversDMX)); + + void ConstruitCBUnivers () + { + caseBrk.Text = drv.Break.ToString (); + caseMab.Text = drv.Mab.ToString (); + + chkMerge1.Active = drv.Flag_merge1 == 1; + + cbUnivers1.Model = lsCbUnivers1; + var cellCbUnivers1 = new CellRendererText (); + cbUnivers1.PackStart (cellCbUnivers1, false); + cbUnivers1.SetCellDataFunc (cellCbUnivers1, new CellLayoutDataFunc (RenderUniversName1)); + + int indx = 0; + int i = 0; + foreach (UniversDMX u in Conduite.Courante.Patches) { + lsCbUnivers1.AppendValues (u); + if (u==drv.patch1) indx=i; + i++; + } + + TreeIter iter; + lsCbUnivers1.GetIterFirst (out iter); + cbUnivers1.SetActiveIter (iter); + cbUnivers1.Active=indx; + + + } + + void RenderUniversName1 (CellLayout cell_layout, CellRenderer cell, TreeModel tree_model, TreeIter iter) + { + UniversDMX univers = tree_model.GetValue (iter, 0) as UniversDMX; + if(univers != null) + (cell as Gtk.CellRendererText).Text = univers.Nom; + } + + void RenderUniversName2 (CellLayout cell_layout, CellRenderer cell, TreeModel tree_model, TreeIter iter) + { + UniversDMX univers = tree_model.GetValue (iter, 0) as UniversDMX; + if(univers != null) + (cell as Gtk.CellRendererText).Text = univers.Nom; + } + + protected void OnButtonValider (object sender, EventArgs e) + { + TreeIter iter; + if (cbUnivers1.GetActiveIter (out iter)) { + drv.patch1 = lsCbUnivers1.GetValue (iter, 0) as UniversDMX; + } + + + int a, b; + if (!int.TryParse (caseBrk.Text, out a)) + return; + if (!int.TryParse (caseMab.Text, out b)) + return; + if (a < 92) { + a = 92; + } + if (b < 12) { + b = 12; + } + drv.SetBreak(a,b,(byte)(chkMerge1.Active?1:0)); + + } + + protected void OnBtnInitClicked (object sender, EventArgs e) + { + drv.ReInit(); + } + + + + } +} + diff --git a/DMX-2.0/GestionDriversUI.cs b/DMX-2.0/GestionDriversUI.cs index 867ff30..baf0e93 100644 --- a/DMX-2.0/GestionDriversUI.cs +++ b/DMX-2.0/GestionDriversUI.cs @@ -38,6 +38,7 @@ namespace DMX2 lsDriver = new Gtk.ListStore(typeof (String)); lsDriver.AppendValues("V1 256/0/0/8"); lsDriver.AppendValues("V2 1024/512/16/16"); + lsDriver.AppendValues("V3 512/512"); comboDriver.Model = lsDriver; @@ -159,6 +160,12 @@ namespace DMX2 Conduite.Courante.DriversAdd(drv); break; + case 2: + drv = new DriverBoitierV3(fi.FullName, fi.Name); + Conduite.Courante.DriversAdd(drv); + + break; + default: return; } diff --git a/DMX-2.0/gtk-gui/DMX2.DriverBoitierV3UI.cs b/DMX-2.0/gtk-gui/DMX2.DriverBoitierV3UI.cs new file mode 100644 index 0000000..8cc97c0 --- /dev/null +++ b/DMX-2.0/gtk-gui/DMX2.DriverBoitierV3UI.cs @@ -0,0 +1,204 @@ + +// This file has been generated by the GUI designer. Do not modify. +namespace DMX2 +{ + public partial class DriverBoitierV3UI + { + private global::Gtk.VBox vbox2; + private global::Gtk.Label label1; + private global::Gtk.Table table1; + private global::Gtk.Entry caseBrk; + private global::Gtk.Entry caseMab; + private global::Gtk.ComboBox cbUnivers1; + private global::Gtk.CheckButton chkMerge1; + private global::Gtk.Label label2; + private global::Gtk.Label label3; + private global::Gtk.Label label4; + private global::Gtk.Label label5; + private global::Gtk.Label label6; + private global::Gtk.Label label8; + private global::Gtk.HBox hbox1; + private global::Gtk.Button btnValider; + private global::Gtk.Button btnInit; + + protected virtual void Build () + { + global::Stetic.Gui.Initialize (this); + // Widget DMX2.DriverBoitierV3UI + global::Stetic.BinContainer.Attach (this); + this.Name = "DMX2.DriverBoitierV3UI"; + // Container child DMX2.DriverBoitierV3UI.Gtk.Container+ContainerChild + this.vbox2 = new global::Gtk.VBox (); + this.vbox2.Name = "vbox2"; + this.vbox2.Spacing = 6; + // Container child vbox2.Gtk.Box+BoxChild + this.label1 = new global::Gtk.Label (); + this.label1.Name = "label1"; + this.label1.LabelProp = "Driver V3"; + this.vbox2.Add (this.label1); + global::Gtk.Box.BoxChild w1 = ((global::Gtk.Box.BoxChild)(this.vbox2 [this.label1])); + w1.Position = 0; + w1.Expand = false; + w1.Fill = false; + // Container child vbox2.Gtk.Box+BoxChild + this.table1 = new global::Gtk.Table (((uint)(3)), ((uint)(5)), false); + this.table1.Name = "table1"; + this.table1.RowSpacing = ((uint)(6)); + this.table1.ColumnSpacing = ((uint)(6)); + // Container child table1.Gtk.Table+TableChild + this.caseBrk = new global::Gtk.Entry (); + this.caseBrk.CanFocus = true; + this.caseBrk.Name = "caseBrk"; + this.caseBrk.IsEditable = true; + this.caseBrk.InvisibleChar = '•'; + this.table1.Add (this.caseBrk); + global::Gtk.Table.TableChild w2 = ((global::Gtk.Table.TableChild)(this.table1 [this.caseBrk])); + w2.TopAttach = ((uint)(1)); + w2.BottomAttach = ((uint)(2)); + w2.LeftAttach = ((uint)(2)); + w2.RightAttach = ((uint)(3)); + w2.XOptions = ((global::Gtk.AttachOptions)(4)); + w2.YOptions = ((global::Gtk.AttachOptions)(4)); + // Container child table1.Gtk.Table+TableChild + this.caseMab = new global::Gtk.Entry (); + this.caseMab.CanFocus = true; + this.caseMab.Name = "caseMab"; + this.caseMab.IsEditable = true; + this.caseMab.InvisibleChar = '•'; + this.table1.Add (this.caseMab); + global::Gtk.Table.TableChild w3 = ((global::Gtk.Table.TableChild)(this.table1 [this.caseMab])); + w3.TopAttach = ((uint)(1)); + w3.BottomAttach = ((uint)(2)); + w3.LeftAttach = ((uint)(3)); + w3.RightAttach = ((uint)(4)); + w3.XOptions = ((global::Gtk.AttachOptions)(4)); + w3.YOptions = ((global::Gtk.AttachOptions)(4)); + // Container child table1.Gtk.Table+TableChild + this.cbUnivers1 = global::Gtk.ComboBox.NewText (); + this.cbUnivers1.Name = "cbUnivers1"; + this.table1.Add (this.cbUnivers1); + global::Gtk.Table.TableChild w4 = ((global::Gtk.Table.TableChild)(this.table1 [this.cbUnivers1])); + w4.TopAttach = ((uint)(1)); + w4.BottomAttach = ((uint)(2)); + w4.LeftAttach = ((uint)(1)); + w4.RightAttach = ((uint)(2)); + w4.XOptions = ((global::Gtk.AttachOptions)(4)); + w4.YOptions = ((global::Gtk.AttachOptions)(4)); + // Container child table1.Gtk.Table+TableChild + this.chkMerge1 = new global::Gtk.CheckButton (); + this.chkMerge1.CanFocus = true; + this.chkMerge1.Name = "chkMerge1"; + this.chkMerge1.Label = ""; + this.chkMerge1.DrawIndicator = true; + this.chkMerge1.UseUnderline = true; + this.table1.Add (this.chkMerge1); + global::Gtk.Table.TableChild w5 = ((global::Gtk.Table.TableChild)(this.table1 [this.chkMerge1])); + w5.TopAttach = ((uint)(1)); + w5.BottomAttach = ((uint)(2)); + w5.LeftAttach = ((uint)(4)); + w5.RightAttach = ((uint)(5)); + w5.XOptions = ((global::Gtk.AttachOptions)(4)); + w5.YOptions = ((global::Gtk.AttachOptions)(4)); + // Container child table1.Gtk.Table+TableChild + this.label2 = new global::Gtk.Label (); + this.label2.Name = "label2"; + this.label2.LabelProp = "Etat"; + this.table1.Add (this.label2); + global::Gtk.Table.TableChild w6 = ((global::Gtk.Table.TableChild)(this.table1 [this.label2])); + w6.XOptions = ((global::Gtk.AttachOptions)(4)); + w6.YOptions = ((global::Gtk.AttachOptions)(4)); + // Container child table1.Gtk.Table+TableChild + this.label3 = new global::Gtk.Label (); + this.label3.Name = "label3"; + this.label3.LabelProp = "Univer associé"; + this.table1.Add (this.label3); + global::Gtk.Table.TableChild w7 = ((global::Gtk.Table.TableChild)(this.table1 [this.label3])); + w7.LeftAttach = ((uint)(1)); + w7.RightAttach = ((uint)(2)); + w7.XOptions = ((global::Gtk.AttachOptions)(4)); + w7.YOptions = ((global::Gtk.AttachOptions)(4)); + // Container child table1.Gtk.Table+TableChild + this.label4 = new global::Gtk.Label (); + this.label4.Name = "label4"; + this.label4.LabelProp = "Break"; + this.table1.Add (this.label4); + global::Gtk.Table.TableChild w8 = ((global::Gtk.Table.TableChild)(this.table1 [this.label4])); + w8.LeftAttach = ((uint)(2)); + w8.RightAttach = ((uint)(3)); + w8.XOptions = ((global::Gtk.AttachOptions)(4)); + w8.YOptions = ((global::Gtk.AttachOptions)(4)); + // Container child table1.Gtk.Table+TableChild + this.label5 = new global::Gtk.Label (); + this.label5.Name = "label5"; + this.label5.LabelProp = "MAB"; + this.table1.Add (this.label5); + global::Gtk.Table.TableChild w9 = ((global::Gtk.Table.TableChild)(this.table1 [this.label5])); + w9.LeftAttach = ((uint)(3)); + w9.RightAttach = ((uint)(4)); + w9.XOptions = ((global::Gtk.AttachOptions)(4)); + w9.YOptions = ((global::Gtk.AttachOptions)(4)); + // Container child table1.Gtk.Table+TableChild + this.label6 = new global::Gtk.Label (); + this.label6.Name = "label6"; + this.label6.LabelProp = "Block 1"; + this.table1.Add (this.label6); + global::Gtk.Table.TableChild w10 = ((global::Gtk.Table.TableChild)(this.table1 [this.label6])); + w10.TopAttach = ((uint)(1)); + w10.BottomAttach = ((uint)(2)); + w10.XOptions = ((global::Gtk.AttachOptions)(4)); + w10.YOptions = ((global::Gtk.AttachOptions)(4)); + // Container child table1.Gtk.Table+TableChild + this.label8 = new global::Gtk.Label (); + this.label8.Name = "label8"; + this.label8.LabelProp = "Merge"; + this.table1.Add (this.label8); + global::Gtk.Table.TableChild w11 = ((global::Gtk.Table.TableChild)(this.table1 [this.label8])); + w11.LeftAttach = ((uint)(4)); + w11.RightAttach = ((uint)(5)); + w11.XOptions = ((global::Gtk.AttachOptions)(4)); + w11.YOptions = ((global::Gtk.AttachOptions)(4)); + this.vbox2.Add (this.table1); + global::Gtk.Box.BoxChild w12 = ((global::Gtk.Box.BoxChild)(this.vbox2 [this.table1])); + w12.Position = 1; + // Container child vbox2.Gtk.Box+BoxChild + this.hbox1 = new global::Gtk.HBox (); + this.hbox1.Name = "hbox1"; + this.hbox1.Spacing = 6; + // Container child hbox1.Gtk.Box+BoxChild + this.btnValider = new global::Gtk.Button (); + this.btnValider.CanFocus = true; + this.btnValider.Name = "btnValider"; + this.btnValider.UseUnderline = true; + this.btnValider.Label = "Valider"; + this.hbox1.Add (this.btnValider); + global::Gtk.Box.BoxChild w13 = ((global::Gtk.Box.BoxChild)(this.hbox1 [this.btnValider])); + w13.Position = 1; + w13.Expand = false; + w13.Fill = false; + // Container child hbox1.Gtk.Box+BoxChild + this.btnInit = new global::Gtk.Button (); + this.btnInit.CanFocus = true; + this.btnInit.Name = "btnInit"; + this.btnInit.UseUnderline = true; + this.btnInit.Label = "Init Boitier"; + this.hbox1.Add (this.btnInit); + global::Gtk.Box.BoxChild w14 = ((global::Gtk.Box.BoxChild)(this.hbox1 [this.btnInit])); + w14.Position = 2; + w14.Expand = false; + w14.Fill = false; + this.vbox2.Add (this.hbox1); + global::Gtk.Box.BoxChild w15 = ((global::Gtk.Box.BoxChild)(this.vbox2 [this.hbox1])); + w15.PackType = ((global::Gtk.PackType)(1)); + w15.Position = 2; + w15.Expand = false; + w15.Fill = false; + this.Add (this.vbox2); + if ((this.Child != null)) { + this.Child.ShowAll (); + } + this.Hide (); + this.btnValider.Clicked += new global::System.EventHandler (this.OnButtonValider); + this.btnInit.Clicked += new global::System.EventHandler (this.OnBtnInitClicked); + } + } +} diff --git a/DMX-2.0/gtk-gui/gui.stetic b/DMX-2.0/gtk-gui/gui.stetic index a34bd40..2bb4830 100644 --- a/DMX-2.0/gtk-gui/gui.stetic +++ b/DMX-2.0/gtk-gui/gui.stetic @@ -2632,4 +2632,307 @@ Licence : GPL V2 + + + False + + + + 6 + + + + Driver V3 + + + 0 + True + False + False + + + + + + 3 + 5 + 6 + 6 + + + + + + + + + + + + + + + + + + + True + True + • + + + 1 + 2 + 2 + 3 + True + Fill + Fill + False + True + False + False + True + False + + + + + + True + True + • + + + 1 + 2 + 3 + 4 + True + Fill + Fill + False + True + False + False + True + False + + + + + + True + + + + 1 + 2 + 1 + 2 + True + Fill + Fill + False + True + False + False + True + False + + + + + + True + + True + True + True + + + 1 + 2 + 4 + 5 + True + Fill + Fill + False + True + False + False + True + False + + + + + + Etat + + + True + Fill + Fill + False + True + False + False + True + False + + + + + + Univer associé + + + 1 + 2 + True + Fill + Fill + False + True + False + False + True + False + + + + + + Break + + + 2 + 3 + True + Fill + Fill + False + True + False + False + True + False + + + + + + MAB + + + 3 + 4 + True + Fill + Fill + False + True + False + False + True + False + + + + + + Block 1 + + + 1 + 2 + True + Fill + Fill + False + True + False + False + True + False + + + + + + Merge + + + 4 + 5 + True + Fill + Fill + False + True + False + False + True + False + + + + + 1 + True + + + + + + 6 + + + + + + + True + TextOnly + Valider + True + + + + 1 + True + False + False + + + + + + True + TextOnly + Init Boitier + True + + + + 2 + True + False + False + + + + + End + 2 + True + False + False + + + + + \ No newline at end of file