src/Builder4/WindowLeftProps.bjs
[app.Builder.js] / src / Builder4 / WindowLeftProps.vala
1 static Xcls_LeftProps  _LeftProps;
2
3 public class Xcls_LeftProps : Object
4 {
5     public Gtk.Box el;
6     private Xcls_LeftProps  _this;
7
8     public static Xcls_LeftProps singleton()
9     {
10         if (_LeftProps == null) {
11             _LeftProps= new Xcls_LeftProps();
12         }
13         return _LeftProps;
14     }
15     public Xcls_AddPropertyPopup AddPropertyPopup;
16     public Xcls_EditProps EditProps;
17     public Xcls_view view;
18     public Xcls_model model;
19     public Xcls_keycol keycol;
20     public Xcls_keyrender keyrender;
21     public Xcls_valcol valcol;
22     public Xcls_valrender valrender;
23     public Xcls_valrendermodel valrendermodel;
24     public Xcls_ContextMenu ContextMenu;
25
26         // my vars (def)
27     public bool allow_edit;
28     public JsRender.JsRender file;
29     public signal bool stop_editor ();
30     public signal void show_editor (JsRender.JsRender file, JsRender.Node node, string type, string key);
31     public signal void changed ();
32     public signal void show_add_props (string type);
33     public Xcls_MainWindow main_window;
34     public JsRender.Node node;
35
36     // ctor
37     public Xcls_LeftProps()
38     {
39         _this = this;
40         this.el = new Gtk.Box( Gtk.Orientation.VERTICAL, 0 );
41
42         // my vars (dec)
43         this.allow_edit = false;
44         this.main_window = null;
45
46         // set gobject values
47         this.el.homogeneous = false   ;
48         var child_0 = new Xcls_Box2( _this );
49         child_0.ref();
50         this.el.pack_start (  child_0.el , false,true,0 );
51         var child_1 = new Xcls_EditProps( _this );
52         child_1.ref();
53         this.el.pack_end (  child_1.el , true,true,0 );
54     }
55
56     // user defined functions
57     public void updateKey (string oldkey,  string type, string key ) {
58     
59      
60         
61         _this.model.el.foreach((mod, path,  iter) => {
62                  
63             
64                   
65            
66                  GLib.Value gvaltype, gval,kvalue;
67                  mod.get_value(iter, 1 , out gval); // one is key..
68                 
69              mod.get_value(iter,0, out gvaltype);
70              
71              mod.get_value(iter,3, out kvalue);
72              
73               if (oldkey == ((string)gval) && type == ((string)gvaltype)) {
74                       this.updateIter(iter, type, key, (string)kvalue);
75                       return true;
76                   }
77              
78     
79                 return false;
80         });
81         
82         this.changed();
83     
84     
85     }
86     public              void before_edit ()
87     {
88     
89         print("before edit - stop editing\n");
90         
91       // these do not appear to trigger save...
92         _this.keyrender.el.stop_editing(false);
93         _this.keyrender.el.editable  =false;
94     
95         _this.valrender.el.stop_editing(false);
96         _this.valrender.el.editable  =false;    
97         
98         
99     // technicall stop the popup editor..
100     
101     }
102     public              string keySortFormat (string key) {
103         // listeners first - with 0
104         // specials
105         if (key[0] == '*') {
106             return "1 " + key;
107         }
108         // functions
109         
110         var bits = key.split(" ");
111         
112         if (key[0] == '|') {
113             return "2 " + bits[bits.length -1];
114         }
115         // signals
116         if (key[0] == '@') {
117             return "3 " + bits[bits.length -1];
118         }
119             
120         // props
121         if (key[0] == '#') {
122             return "4 " + bits[bits.length -1];
123         }
124         // the rest..
125         return "5 " + bits[bits.length -1];    
126     
127     
128     
129     }
130     public              void finish_editing () {
131          // 
132         this.before_edit();
133     }
134     public              bool startEditingValue ( Gtk.TreePath path) {
135     
136          // ONLY return true if editing is allowed - eg. combo..
137     
138         print("start editing?\n");
139         if (!this.stop_editor()) {
140             print("stop editor failed\n");
141             return false;
142         }
143         
144         Gtk.TreeIter iter;
145     
146         var mod = this.model.el;
147         mod.get_iter (out iter, path);
148          
149         /*
150             m.set(iter, 
151                     0, "listener",
152                     1, miter.get_key(),
153                     2, "<b>" + miter.get_key() + "</b>",
154                     3, miter.get_value()
155                 ); 
156          
157         */
158         GLib.Value gval;
159         mod.get_value(iter, 3 , out gval);
160         var val = (string)gval;
161     
162         mod.get_value(iter, 1 , out gval);
163         var key = (string)gval;
164         
165         
166         string kname, kflag, ktype;
167         this.node.normalize_key(key, out kname, out kflag, out ktype);
168          
169         
170         mod.get_value(iter, 0 , out gval);
171         var type = (string)gval; // listerner or prop..
172         
173        
174         
175         var use_textarea = false;
176     
177         //------------ things that require the text editor...
178         
179         if (type == "listener") {
180             use_textarea = true;
181         }
182         if (key.length > 0 && key[0] == '|') { // user defined method
183             use_textarea = true;
184         }
185         if (key.length > 0 && key[0] == '$') { // raw string
186             use_textarea = true;
187         }
188         if (key.length > 0 && key == "* init") {
189             use_textarea = true;
190         }
191         if (val.length > 40) { // long value...
192             use_textarea = true;
193         }
194         
195         
196         
197         if (use_textarea) {
198             print("Call show editor\n");
199             GLib.Timeout.add_full(GLib.Priority.DEFAULT,10 , () => {
200                 this.view.el.get_selection().select_path(path);
201                 
202                 this.show_editor(file, node, type, key);
203                 
204                 return false;
205             });
206            
207             
208             return false;
209         }
210         
211          var pal = Palete.factory(this.file.project.xtype);
212         
213         string[] opts;
214         var has_opts = pal.typeOptions(this.node.fqn(), kname, ktype, out opts);
215         
216         
217         
218         // others... - fill in options for true/false?
219         print("turn on editing %s \n" , mod.get_path(iter).to_string());
220        
221            print (ktype.up());
222         if (has_opts) {
223                 print("start editing try/false)???");
224                 this.valrender.el.has_entry = false;
225               
226                 this.valrender.setOptions(opts);
227                 
228                 this.valrender.el.has_entry = false;
229                 this.valrender.el.editable = true;
230                  this.allow_edit  = true;
231                  GLib.Timeout.add_full(GLib.Priority.DEFAULT,100 , () => {
232                      this.view.el.set_cursor_on_cell(
233                         path,
234                         this.valcol.el,
235                         this.valrender.el,
236                         true
237                     );
238                     return false;
239                 });
240                 return true;
241         }
242                                   
243            // see if type is a Enum.
244            
245            
246        
247             
248        
249          opts =  {  };
250         this.valrender.setOptions(opts);
251        
252        GLib.Timeout.add_full(GLib.Priority.DEFAULT,10 , () => {
253             
254             // at this point - work out the type...
255             // if its' a combo... then show the options..
256             this.valrender.el.has_entry = true;
257             
258             this.valrender.el.editable = true;            
259         
260             
261             this.allow_edit  = true;
262             
263             
264             
265             
266     
267             this.view.el.set_cursor_on_cell(
268                 path,
269                 this.valcol.el,
270                 this.valrender.el,
271                 true
272             );
273             return false;
274         });
275         return false;
276     }
277     public              void load (JsRender.JsRender file, JsRender.Node? node) 
278     {
279         print("load leftprops\n");
280         this.before_edit();
281         this.node = node;
282         this.file = file;
283         
284      
285         this.model.el.clear();
286                   
287         //this.get('/RightEditor').el.hide();
288         if (node ==null) {
289             return ;
290         }
291          
292         
293     
294         //var provider = this.get('/LeftTree').getPaleteProvider();
295         Gtk.TreeIter iter;
296         
297         //typeof(string),  // 0 key type
298          //typeof(string),  // 1 key
299          //typeof(string),  // 2 key (display)
300          //typeof(string),  // 3 value
301          //typeof(string),  // 4 value (display)
302          //typeof(string),  // 5 both (tooltip)
303         
304         
305         
306         
307         // really need a way to sort the hashmap...
308         var m = this.model.el;
309         
310         var miter = node.listeners.map_iterator();
311         var i = 0;
312         
313         while(miter.next()) {
314             i++;
315             m.append(out iter,null);
316             
317             this.updateIter(iter,  "listener", miter.get_key(), miter.get_value());
318             
319              
320          }
321          
322           
323         miter = node.props.map_iterator();
324         
325         
326        while(miter.next()) {
327                i++;
328             m.append(out iter,null);
329              this.updateIter(iter,  "prop", miter.get_key(), miter.get_value());
330              
331        }
332        print("clear selection\n");
333        // clear selection?
334        this.model.el.set_sort_column_id(6,Gtk.SortType.ASCENDING); // sort by real key..
335        
336        this.view.el.get_selection().unselect_all();
337        
338        var pane = _this.main_window.editpane.el;
339         var try_size = (i * 25) + 60; // est. 20px per line + 40px header
340         
341         // max 80%...
342         pane.set_position( 
343              ((try_size * 1.0f) /  (pane.max_position * 1.0f))  > 0.8f  ? 
344             (int) (pane.max_position * 0.2f) :
345             pane.max_position-try_size);
346         
347        
348     }
349     public              string keyFormat (string val, string type) {
350         
351         // Glib.markup_escape_text(val);
352     
353         if (type == "listener") {
354             return "<span font_weight=\"bold\" color=\"#660000\">" + 
355                 GLib.Markup.escape_text(val) +
356                  "</span>";
357         }
358         // property..
359         if (val.length < 1) {
360             return "<span  color=\"#FF0000\">--empty--</span>";
361         }
362         
363         //@ = signal
364         //$ = property with 
365         //# - object properties
366         //* = special
367         // all of these... - display value is last element..
368         var ar = val.strip().split(" ");
369         
370         
371         var dval = GLib.Markup.escape_text(ar[ar.length-1]);
372         
373         
374         
375         
376         switch(val[0]) {
377             case '@': // signal // just bold balck?
378                 if (dval[0] == '@') {
379                     dval = dval.substring(1);
380                 }
381             
382                 return @"<span  font_weight=\"bold\">@ $dval</span>";        
383             case '#': // object properties?
384                 if (dval[0] == '#') {
385                     dval = dval.substring(1);
386                 }
387                 return @"<span  font_weight=\"bold\">$dval</span>";
388             case '*': // special
389                 if (dval[0] == '*') {
390                     dval = dval.substring(1);
391                 }
392                 return @"<span   color=\"#0000CC\" font_weight=\"bold\">$dval</span>";            
393             case '$':
394                 if (dval[0] == '$') {
395                     dval = dval.substring(1);
396                 }
397                 return @"<span   style=\"italic\">$dval</span>";
398            case '|': // user defined methods
399                 if (dval[0] == '|') {
400                     dval = dval.substring(1);
401                 }
402                 return @"<span color=\"#008000\" font_weight=\"bold\">$dval</span>";
403                 
404                   
405                 
406             default:
407                 return dval;
408         }
409           
410         
411     
412     }
413     public              void deleteSelected () {
414         
415             Gtk.TreeIter iter;
416             Gtk.TreeModel mod;
417             
418             var s = this.view.el.get_selection();
419             s.get_selected(out mod, out iter);
420                  
421                   
422             GLib.Value gval;
423             mod.get_value(iter, 0 , out gval);
424             var type = (string)gval;
425             
426             mod.get_value(iter, 1 , out gval);
427             var key = (string)gval;
428             
429             switch(type) {
430                 case "listener":
431                     this.node.listeners.unset(key);
432                     break;
433                     
434                 case "props":
435                     this.node.props.unset(key);
436                     break;
437             }
438             this.load(this.file, this.node);
439             
440             _this.changed();
441     }
442     public              void startEditingKey ( Gtk.TreePath path) {
443         
444          if (!this.stop_editor()) {
445             return;
446          }
447       
448         // others... - fill in options for true/false?
449         
450            
451         GLib.Timeout.add_full(GLib.Priority.DEFAULT,10 , () => {
452             this.allow_edit  = true;
453             this.keyrender.el.editable = true;
454          
455             this.view.el.set_cursor_on_cell(
456                 path,
457                 this.keycol.el,
458                 this.keyrender.el,
459                 true
460             );
461                    
462             return false;
463         });
464           
465         
466     }
467     public              void addProp (string in_type, string key, string value, string value_type) {
468           // info includes key, val, skel, etype..
469           //console.dump(info);
470             //type = info.type.toLowerCase();
471             //var data = this.toJS();
472               
473         var type = in_type == "signals" ? "listener" : in_type;
474           
475         var fkey = (value_type.length > 0 ? value_type + " " : "") + key;
476                   
477         if (type == "listener") {
478             if (this.node.listeners.has_key(key)) {
479                 return;
480             }
481             this.node.listeners.set(key,value);
482         } else  {
483         
484             if (this.node.props.has_key(fkey)) {
485                 return;
486             }
487             this.node.props.set(fkey,value);
488         }
489                 
490           
491         // add a row???
492         this.load(this.file, this.node);
493         
494         
495         
496         /// need to find the row which I've just added..
497         
498         
499         var s = this.view.el.get_selection();
500         s.unselect_all();
501         
502         print("trying to find new iter");
503       
504         this.model.el.foreach((model, path, iter) => {
505             GLib.Value gval;
506         
507             this.model.el.get_value(iter, 0 , out gval);
508             if ((string)gval != type) {
509                 print("not type: %s = %s\n", (string)gval , type);
510                 return false;
511             }
512             this.model.el.get_value(iter, 1 , out gval);
513             if ((string)gval != fkey) {
514                 print("not key: %s = %s\n", (string)gval , fkey);
515                 return false;
516             }
517             // delay this?
518             GLib.Timeout.add_full(GLib.Priority.DEFAULT,40 , () => {
519             
520                 this.startEditingValue(this.model.el.get_path(iter));
521                 return false;
522             });
523             //s.select_iter(iter);
524             return true; 
525         });
526         
527         
528         
529                   
530     }
531     public              void updateIter (Gtk.TreeIter iter,  string type, string key, string kvalue) {
532     
533         print("update Iter %s, %s\n", key,value);
534         //typeof(string),  // 0 key type
535          //typeof(string),  // 1 key
536          //typeof(string),  // 2 key (display)
537          //typeof(string),  // 3 value
538          //typeof(string),  // 4 value (display)
539          //typeof(string),  // 5 both (tooltip)
540          //typeof(string),  // 6 key (sort)
541         
542         var dl = value.strip().split("\n");
543     
544         var dis_val = dl.length > 1 ? (dl[0].strip()+ "...") : dl[0];
545         
546         if (type == "listener") {
547          
548            
549             
550             this.model.el.set(iter, 
551                     0, type,
552                 1, key,
553                 2, this.keyFormat(key ,type),
554                 3, kvalue,
555                 4, dis_val,
556                 5, "<tt>" +  GLib.Markup.escape_text(key + " " +value) + "</tt>",
557                 6,  "0 " + key
558             ); 
559             return;
560         }
561         
562     
563     
564         this.model.el.set(iter, 
565                 0, "props",
566                 1, key,
567                 2,  this.keyFormat(key , "prop"),
568                 3, kvalue,
569                 4, dis_val,
570                  5, "<tt>" + GLib.Markup.escape_text(key + " " + value) + "</tt>",
571                  6,  this.keySortFormat(key)
572             ); 
573     }
574     public class Xcls_Box2 : Object
575     {
576         public Gtk.Box el;
577         private Xcls_LeftProps  _this;
578
579
580             // my vars (def)
581
582         // ctor
583         public Xcls_Box2(Xcls_LeftProps _owner )
584         {
585             _this = _owner;
586             this.el = new Gtk.Box( Gtk.Orientation.HORIZONTAL, 0 );
587
588             // my vars (dec)
589
590             // set gobject values
591             var child_0 = new Xcls_Button3( _this );
592             child_0.ref();
593             this.el.add (  child_0.el  );
594         }
595
596         // user defined functions
597     }
598     public class Xcls_Button3 : Object
599     {
600         public Gtk.Button el;
601         private Xcls_LeftProps  _this;
602
603
604             // my vars (def)
605
606         // ctor
607         public Xcls_Button3(Xcls_LeftProps _owner )
608         {
609             _this = _owner;
610             this.el = new Gtk.Button();
611
612             // my vars (dec)
613
614             // set gobject values
615             this.el.hexpand = true;
616             var child_0 = new Xcls_Box4( _this );
617             child_0.ref();
618             this.el.add (  child_0.el  );
619             var child_1 = new Xcls_AddPropertyPopup( _this );
620             child_1.ref();
621
622             //listeners
623             this.el.button_press_event.connect( (self, ev) => {
624                 _this.before_edit();
625                 
626                     
627                 var p = _this.AddPropertyPopup;
628                 p.el.set_screen(Gdk.Screen.get_default());
629                 p.el.show_all();
630                  p.el.popup(null, null, null, ev.button, ev.time);
631                  return true;
632             });
633         }
634
635         // user defined functions
636     }
637     public class Xcls_Box4 : Object
638     {
639         public Gtk.Box el;
640         private Xcls_LeftProps  _this;
641
642
643             // my vars (def)
644
645         // ctor
646         public Xcls_Box4(Xcls_LeftProps _owner )
647         {
648             _this = _owner;
649             this.el = new Gtk.Box( Gtk.Orientation.HORIZONTAL, 0 );
650
651             // my vars (dec)
652
653             // set gobject values
654             var child_0 = new Xcls_Image5( _this );
655             child_0.ref();
656             this.el.add (  child_0.el  );
657             var child_1 = new Xcls_Label6( _this );
658             child_1.ref();
659             this.el.add (  child_1.el  );
660         }
661
662         // user defined functions
663     }
664     public class Xcls_Image5 : Object
665     {
666         public Gtk.Image el;
667         private Xcls_LeftProps  _this;
668
669
670             // my vars (def)
671
672         // ctor
673         public Xcls_Image5(Xcls_LeftProps _owner )
674         {
675             _this = _owner;
676             this.el = new Gtk.Image();
677
678             // my vars (dec)
679
680             // set gobject values
681             this.el.stock = Gtk.Stock.ADD;
682             this.el.icon_size = Gtk.IconSize.MENU;
683         }
684
685         // user defined functions
686     }
687
688     public class Xcls_Label6 : Object
689     {
690         public Gtk.Label el;
691         private Xcls_LeftProps  _this;
692
693
694             // my vars (def)
695
696         // ctor
697         public Xcls_Label6(Xcls_LeftProps _owner )
698         {
699             _this = _owner;
700             this.el = new Gtk.Label( "Other" );
701
702             // my vars (dec)
703
704             // set gobject values
705         }
706
707         // user defined functions
708     }
709
710
711     public class Xcls_AddPropertyPopup : Object
712     {
713         public Gtk.Menu el;
714         private Xcls_LeftProps  _this;
715
716
717             // my vars (def)
718
719         // ctor
720         public Xcls_AddPropertyPopup(Xcls_LeftProps _owner )
721         {
722             _this = _owner;
723             _this.AddPropertyPopup = this;
724             this.el = new Gtk.Menu();
725
726             // my vars (dec)
727
728             // set gobject values
729             var child_0 = new Xcls_MenuItem8( _this );
730             child_0.ref();
731             this.el.append (  child_0.el  );
732             var child_1 = new Xcls_MenuItem9( _this );
733             child_1.ref();
734             this.el.append (  child_1.el  );
735             var child_2 = new Xcls_MenuItem10( _this );
736             child_2.ref();
737             this.el.append (  child_2.el  );
738             var child_3 = new Xcls_MenuItem11( _this );
739             child_3.ref();
740             this.el.append (  child_3.el  );
741             var child_4 = new Xcls_SeparatorMenuItem12( _this );
742             child_4.ref();
743             this.el.add (  child_4.el  );
744             var child_5 = new Xcls_MenuItem13( _this );
745             child_5.ref();
746             this.el.append (  child_5.el  );
747             var child_6 = new Xcls_MenuItem14( _this );
748             child_6.ref();
749             this.el.append (  child_6.el  );
750             var child_7 = new Xcls_MenuItem15( _this );
751             child_7.ref();
752             this.el.append (  child_7.el  );
753             var child_8 = new Xcls_SeparatorMenuItem16( _this );
754             child_8.ref();
755             this.el.add (  child_8.el  );
756             var child_9 = new Xcls_MenuItem17( _this );
757             child_9.ref();
758             this.el.append (  child_9.el  );
759             var child_10 = new Xcls_MenuItem18( _this );
760             child_10.ref();
761             this.el.append (  child_10.el  );
762             var child_11 = new Xcls_MenuItem19( _this );
763             child_11.ref();
764             this.el.append (  child_11.el  );
765             var child_12 = new Xcls_SeparatorMenuItem20( _this );
766             child_12.ref();
767             this.el.add (  child_12.el  );
768             var child_13 = new Xcls_MenuItem21( _this );
769             child_13.ref();
770             this.el.append (  child_13.el  );
771             var child_14 = new Xcls_MenuItem22( _this );
772             child_14.ref();
773             this.el.append (  child_14.el  );
774             var child_15 = new Xcls_MenuItem23( _this );
775             child_15.ref();
776             this.el.append (  child_15.el  );
777         }
778
779         // user defined functions
780     }
781     public class Xcls_MenuItem8 : Object
782     {
783         public Gtk.MenuItem el;
784         private Xcls_LeftProps  _this;
785
786
787             // my vars (def)
788
789         // ctor
790         public Xcls_MenuItem8(Xcls_LeftProps _owner )
791         {
792             _this = _owner;
793             this.el = new Gtk.MenuItem();
794
795             // my vars (dec)
796
797             // set gobject values
798             this.el.tooltip_markup = "Using _this.{ID} will map to this element";
799             this.el.label = "id: _this.{ID} (Vala)";
800
801             //listeners
802             this.el.activate.connect( ()  => {
803                 _this.addProp( "prop", "id", "", "");
804             });
805         }
806
807         // user defined functions
808     }
809
810     public class Xcls_MenuItem9 : Object
811     {
812         public Gtk.MenuItem el;
813         private Xcls_LeftProps  _this;
814
815
816             // my vars (def)
817
818         // ctor
819         public Xcls_MenuItem9(Xcls_LeftProps _owner )
820         {
821             _this = _owner;
822             this.el = new Gtk.MenuItem();
823
824             // my vars (dec)
825
826             // set gobject values
827             this.el.tooltip_markup = "how to pack this element onto parent, (method, 2nd arg, 3rd arg) .. the 1st argument is filled by the element";
828             this.el.label = "pack: Pack method (Vala)";
829
830             //listeners
831             this.el.activate.connect( ( ) => {
832             
833                 _this.addProp( "prop", "pack","add", "*");
834             });
835         }
836
837         // user defined functions
838     }
839
840     public class Xcls_MenuItem10 : Object
841     {
842         public Gtk.MenuItem el;
843         private Xcls_LeftProps  _this;
844
845
846             // my vars (def)
847
848         // ctor
849         public Xcls_MenuItem10(Xcls_LeftProps _owner )
850         {
851             _this = _owner;
852             this.el = new Gtk.MenuItem();
853
854             // my vars (dec)
855
856             // set gobject values
857             this.el.tooltip_markup = "eg. \n\nnew Clutter.Image.from_file(.....)";
858             this.el.label = "ctor: Alterative to default contructor";
859
860             //listeners
861             this.el.activate.connect( ( ) => {
862             
863                 _this.addProp( "prop", "ctor","", "*");
864             });
865         }
866
867         // user defined functions
868     }
869
870     public class Xcls_MenuItem11 : Object
871     {
872         public Gtk.MenuItem el;
873         private Xcls_LeftProps  _this;
874
875
876             // my vars (def)
877
878         // ctor
879         public Xcls_MenuItem11(Xcls_LeftProps _owner )
880         {
881             _this = _owner;
882             this.el = new Gtk.MenuItem();
883
884             // my vars (dec)
885
886             // set gobject values
887             this.el.tooltip_markup = "This code is called after the ctor";
888             this.el.label = "init: initialziation code (vala)";
889
890             //listeners
891             this.el.activate.connect( ( ) => {
892             
893                 _this.addProp( "prop",  "init", "{\n\n}\n", "*" );
894             });
895         }
896
897         // user defined functions
898     }
899
900     public class Xcls_SeparatorMenuItem12 : Object
901     {
902         public Gtk.SeparatorMenuItem el;
903         private Xcls_LeftProps  _this;
904
905
906             // my vars (def)
907
908         // ctor
909         public Xcls_SeparatorMenuItem12(Xcls_LeftProps _owner )
910         {
911             _this = _owner;
912             this.el = new Gtk.SeparatorMenuItem();
913
914             // my vars (dec)
915
916             // set gobject values
917         }
918
919         // user defined functions
920     }
921
922     public class Xcls_MenuItem13 : Object
923     {
924         public Gtk.MenuItem el;
925         private Xcls_LeftProps  _this;
926
927
928             // my vars (def)
929
930         // ctor
931         public Xcls_MenuItem13(Xcls_LeftProps _owner )
932         {
933             _this = _owner;
934             this.el = new Gtk.MenuItem();
935
936             // my vars (dec)
937
938             // set gobject values
939             this.el.tooltip_markup = "Add a user defined string property";
940             this.el.label = "String";
941
942             //listeners
943             this.el.activate.connect( (self) => {
944             
945                 _this.addProp( "prop", "XXXX", "","string");
946             
947             });
948         }
949
950         // user defined functions
951     }
952
953     public class Xcls_MenuItem14 : Object
954     {
955         public Gtk.MenuItem el;
956         private Xcls_LeftProps  _this;
957
958
959             // my vars (def)
960
961         // ctor
962         public Xcls_MenuItem14(Xcls_LeftProps _owner )
963         {
964             _this = _owner;
965             this.el = new Gtk.MenuItem();
966
967             // my vars (dec)
968
969             // set gobject values
970             this.el.tooltip_markup = "Add a user defined number property";
971             this.el.label = "Number";
972
973             //listeners
974             this.el.activate.connect( ( ) =>{
975             
976                 _this.addProp("prop",  "XXX", "0", "int");
977             });
978         }
979
980         // user defined functions
981     }
982
983     public class Xcls_MenuItem15 : Object
984     {
985         public Gtk.MenuItem el;
986         private Xcls_LeftProps  _this;
987
988
989             // my vars (def)
990
991         // ctor
992         public Xcls_MenuItem15(Xcls_LeftProps _owner )
993         {
994             _this = _owner;
995             this.el = new Gtk.MenuItem();
996
997             // my vars (dec)
998
999             // set gobject values
1000             this.el.tooltip_markup = "Add a user defined boolean property";
1001             this.el.label = "Boolean";
1002
1003             //listeners
1004             this.el.activate.connect( ( ) =>{
1005             
1006                 _this.addProp( "prop", "XXX", "true", "bool");
1007             });
1008         }
1009
1010         // user defined functions
1011     }
1012
1013     public class Xcls_SeparatorMenuItem16 : Object
1014     {
1015         public Gtk.SeparatorMenuItem el;
1016         private Xcls_LeftProps  _this;
1017
1018
1019             // my vars (def)
1020
1021         // ctor
1022         public Xcls_SeparatorMenuItem16(Xcls_LeftProps _owner )
1023         {
1024             _this = _owner;
1025             this.el = new Gtk.SeparatorMenuItem();
1026
1027             // my vars (dec)
1028
1029             // set gobject values
1030         }
1031
1032         // user defined functions
1033     }
1034
1035     public class Xcls_MenuItem17 : Object
1036     {
1037         public Gtk.MenuItem el;
1038         private Xcls_LeftProps  _this;
1039
1040
1041             // my vars (def)
1042
1043         // ctor
1044         public Xcls_MenuItem17(Xcls_LeftProps _owner )
1045         {
1046             _this = _owner;
1047             this.el = new Gtk.MenuItem();
1048
1049             // my vars (dec)
1050
1051             // set gobject values
1052             this.el.tooltip_markup = "Add a user function boolean property";
1053             this.el.label = "Javascript Function";
1054
1055             //listeners
1056             this.el.activate.connect( ( ) =>{
1057             
1058                 _this.addProp("prop",  "XXXX", "function() { }", "| function");
1059             });
1060         }
1061
1062         // user defined functions
1063     }
1064
1065     public class Xcls_MenuItem18 : Object
1066     {
1067         public Gtk.MenuItem el;
1068         private Xcls_LeftProps  _this;
1069
1070
1071             // my vars (def)
1072
1073         // ctor
1074         public Xcls_MenuItem18(Xcls_LeftProps _owner )
1075         {
1076             _this = _owner;
1077             this.el = new Gtk.MenuItem();
1078
1079             // my vars (dec)
1080
1081             // set gobject values
1082             this.el.tooltip_markup = "Add a user function boolean property";
1083             this.el.label = "Vala Method";
1084
1085             //listeners
1086             this.el.activate.connect( ( ) =>{
1087             
1088                 _this.addProp( "prop", "XXXX", "() {\n\n}\n", "| return_type");
1089             });
1090         }
1091
1092         // user defined functions
1093     }
1094
1095     public class Xcls_MenuItem19 : Object
1096     {
1097         public Gtk.MenuItem el;
1098         private Xcls_LeftProps  _this;
1099
1100
1101             // my vars (def)
1102
1103         // ctor
1104         public Xcls_MenuItem19(Xcls_LeftProps _owner )
1105         {
1106             _this = _owner;
1107             this.el = new Gtk.MenuItem();
1108
1109             // my vars (dec)
1110
1111             // set gobject values
1112             this.el.tooltip_markup = "Add a vala signal";
1113             this.el.label = "Vala Signal";
1114
1115             //listeners
1116             this.el.activate.connect( ( ) =>{
1117             
1118                 _this.addProp( "prop", "XXXX", "()", "@ void");
1119             });
1120         }
1121
1122         // user defined functions
1123     }
1124
1125     public class Xcls_SeparatorMenuItem20 : Object
1126     {
1127         public Gtk.SeparatorMenuItem el;
1128         private Xcls_LeftProps  _this;
1129
1130
1131             // my vars (def)
1132
1133         // ctor
1134         public Xcls_SeparatorMenuItem20(Xcls_LeftProps _owner )
1135         {
1136             _this = _owner;
1137             this.el = new Gtk.SeparatorMenuItem();
1138
1139             // my vars (dec)
1140
1141             // set gobject values
1142         }
1143
1144         // user defined functions
1145     }
1146
1147     public class Xcls_MenuItem21 : Object
1148     {
1149         public Gtk.MenuItem el;
1150         private Xcls_LeftProps  _this;
1151
1152
1153             // my vars (def)
1154
1155         // ctor
1156         public Xcls_MenuItem21(Xcls_LeftProps _owner )
1157         {
1158             _this = _owner;
1159             this.el = new Gtk.MenuItem();
1160
1161             // my vars (dec)
1162
1163             // set gobject values
1164             this.el.tooltip_markup = "Add a flexy if (for HTML templates)";
1165             this.el.label = "Flexy - If";
1166
1167             //listeners
1168             this.el.activate.connect( ( ) =>{
1169             
1170                 _this.addProp("prop",  "flexy:if", "value_or_condition", "string");
1171             });
1172         }
1173
1174         // user defined functions
1175     }
1176
1177     public class Xcls_MenuItem22 : Object
1178     {
1179         public Gtk.MenuItem el;
1180         private Xcls_LeftProps  _this;
1181
1182
1183             // my vars (def)
1184
1185         // ctor
1186         public Xcls_MenuItem22(Xcls_LeftProps _owner )
1187         {
1188             _this = _owner;
1189             this.el = new Gtk.MenuItem();
1190
1191             // my vars (dec)
1192
1193             // set gobject values
1194             this.el.tooltip_markup = "Add a flexy include (for HTML templates)";
1195             this.el.label = "Flexy - Include";
1196
1197             //listeners
1198             this.el.activate.connect( ( ) =>{
1199             
1200                 _this.addProp("prop",  "flexy:include", "name_of_file.html", "string");
1201             });
1202         }
1203
1204         // user defined functions
1205     }
1206
1207     public class Xcls_MenuItem23 : Object
1208     {
1209         public Gtk.MenuItem el;
1210         private Xcls_LeftProps  _this;
1211
1212
1213             // my vars (def)
1214
1215         // ctor
1216         public Xcls_MenuItem23(Xcls_LeftProps _owner )
1217         {
1218             _this = _owner;
1219             this.el = new Gtk.MenuItem();
1220
1221             // my vars (dec)
1222
1223             // set gobject values
1224             this.el.tooltip_markup = "Add a flexy foreach (for HTML templates)";
1225             this.el.label = "Flexy - Foreach";
1226
1227             //listeners
1228             this.el.activate.connect( ( ) =>{
1229             
1230                 _this.addProp("prop",  "flexy:foreach", "array,key,value", "string");
1231             });
1232         }
1233
1234         // user defined functions
1235     }
1236
1237
1238
1239
1240     public class Xcls_EditProps : Object
1241     {
1242         public Gtk.ScrolledWindow el;
1243         private Xcls_LeftProps  _this;
1244
1245
1246             // my vars (def)
1247         public bool editing;
1248
1249         // ctor
1250         public Xcls_EditProps(Xcls_LeftProps _owner )
1251         {
1252             _this = _owner;
1253             _this.EditProps = this;
1254             this.el = new Gtk.ScrolledWindow( null, null );
1255
1256             // my vars (dec)
1257             this.editing = false;
1258
1259             // set gobject values
1260             this.el.shadow_type = Gtk.ShadowType.IN;
1261             var child_0 = new Xcls_view( _this );
1262             child_0.ref();
1263             this.el.add (  child_0.el  );
1264
1265             // init method
1266
1267             {
1268               
1269                this.el.set_policy (Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC);
1270             }
1271         }
1272
1273         // user defined functions
1274     }
1275     public class Xcls_view : Object
1276     {
1277         public Gtk.TreeView el;
1278         private Xcls_LeftProps  _this;
1279
1280
1281             // my vars (def)
1282         public Xcls_PopoverProperty popover;
1283
1284         // ctor
1285         public Xcls_view(Xcls_LeftProps _owner )
1286         {
1287             _this = _owner;
1288             _this.view = this;
1289             this.el = new Gtk.TreeView();
1290
1291             // my vars (dec)
1292             this.popover = null;
1293
1294             // set gobject values
1295             this.el.tooltip_column = 5;
1296             this.el.enable_tree_lines = true;
1297             this.el.headers_visible = true;
1298             var child_0 = new Xcls_model( _this );
1299             child_0.ref();
1300             this.el.set_model (  child_0.el  );
1301             var child_1 = new Xcls_keycol( _this );
1302             child_1.ref();
1303             this.el.append_column (  child_1.el  );
1304             var child_2 = new Xcls_valcol( _this );
1305             child_2.ref();
1306             this.el.append_column (  child_2.el  );
1307             var child_3 = new Xcls_ContextMenu( _this );
1308             child_3.ref();
1309
1310             // init method
1311
1312             {
1313                 var selection = this.el.get_selection();
1314                 selection.set_mode( Gtk.SelectionMode.SINGLE);
1315             
1316             
1317                 var description = new Pango.FontDescription();
1318                 description.set_size(10000);
1319                 this.el.override_font(description);
1320             }
1321
1322             //listeners
1323             this.el.button_press_event.connect( ( ev)  => {
1324              
1325                 Gtk.TreeViewColumn col;
1326                 int cell_x;
1327                 int cell_y;
1328                 Gtk.TreePath path;
1329                 if (!this.el.get_path_at_pos((int)ev.x, (int) ev.y, out path, out col, out cell_x, out cell_y )) {
1330                     print("nothing selected on click");
1331                     GLib.Timeout.add_full(GLib.Priority.DEFAULT,10 , () => {
1332                         this.el.get_selection().unselect_all();
1333             
1334                         return false;
1335                     });
1336                      _this.before_edit();
1337                     return false; //not on a element.
1338                 }
1339                 
1340                  
1341                  // double click on name..
1342                  if (ev.type == Gdk.EventType.2BUTTON_PRESS  && ev.button == 1 && col.title == "Name") {    
1343                     // show popup!.   
1344                     
1345                      if (this.popover == null) {
1346                                    this.popover = new Xcls_PopoverProperty();
1347                                    this.popover.mainwindow = _this.main_window;
1348                         }
1349                         
1350              
1351                      _this.before_edit();
1352                       _this.stop_editor();
1353                           
1354                      _this.keyrender.el.stop_editing(false);
1355                      _this.keyrender.el.editable  =false;
1356                 
1357                      _this.valrender.el.stop_editing(false);
1358                      _this.valrender.el.editable  =false;
1359                      Gtk.TreeIter iter;
1360                       var mod = this.el.get_model();
1361                           mod.get_iter (out iter, path);
1362                           
1363                    
1364                         GLib.Value gvaltype, gval;
1365                         mod.get_value(iter, 1 , out gval); // one is key..
1366                         
1367                      mod.get_value(iter,0, out gvaltype);
1368             
1369                     this.popover.show(this.el, _this.node, (string)gvaltype, (string)gval);
1370                        
1371                     //  _this.startEditingKey(path); 
1372                      
1373                     return false;
1374                 }
1375                 
1376                 
1377                 
1378                 
1379                  // right click.
1380                  if (ev.type == Gdk.EventType.BUTTON_PRESS  && ev.button == 3) {    
1381                     // show popup!.   
1382                     //if (col.title == "Value") {
1383                      //     _this.before_edit();
1384                      //    return false;
1385                      //}
1386             
1387                     var p = _this.ContextMenu;
1388             
1389                     p.el.set_screen(Gdk.Screen.get_default());
1390                     p.el.show_all();
1391                     p.el.popup(null, null, null,  ev.button, ev.time);
1392                     //Seed.print("click:" + res.column.title);
1393                     // select the 
1394                     GLib.Timeout.add_full(GLib.Priority.DEFAULT,10 , () => {
1395               
1396                         this.el.get_selection().select_path(path);
1397                         return false;
1398                     });
1399                      _this.before_edit();
1400                     return false;
1401                 }
1402                 
1403                  
1404                 if (col.title != "Value") {
1405                     print("col title != Value");
1406                     
1407                     GLib.Timeout.add_full(GLib.Priority.DEFAULT,10 , () => {
1408                         this.el.get_selection().select_path(path);
1409                         return false;
1410                     });
1411                     
1412                     _this.before_edit();
1413                       //  XObject.error("column is not value?");
1414                     return false; // ignore.. - key click.. ??? should we do this??
1415                 }
1416                 
1417                 
1418                 // if the cell can be edited with a pulldown
1419                 // then we should return true... - and let the start_editing handle it?
1420                 
1421                 
1422                 
1423                 
1424                 
1425                   
1426                //             _this.before_edit(); <<< we really need to stop the other editor..
1427                  _this.keyrender.el.stop_editing(false);
1428                 _this.keyrender.el.editable  =false;
1429                 
1430                        
1431                 return _this.startEditingValue(path); // assumes selected row..
1432                     
1433                
1434             
1435                           
1436                
1437             });
1438         }
1439
1440         // user defined functions
1441     }
1442     public class Xcls_model : Object
1443     {
1444         public Gtk.TreeStore el;
1445         private Xcls_LeftProps  _this;
1446
1447
1448             // my vars (def)
1449
1450         // ctor
1451         public Xcls_model(Xcls_LeftProps _owner )
1452         {
1453             _this = _owner;
1454             _this.model = this;
1455             this.el = new Gtk.TreeStore( 7,      typeof(string),  // 0 key type
1456      typeof(string),  // 1 key
1457      typeof(string),  // 2 key (display)
1458      typeof(string),  // 3 value
1459      typeof(string),   // 4 value (display)
1460      typeof(string),   // 5 both (tooltip)     
1461      typeof(string)   // 6 key (for sorting)
1462  );
1463
1464             // my vars (dec)
1465
1466             // set gobject values
1467         }
1468
1469         // user defined functions
1470     }
1471
1472     public class Xcls_keycol : Object
1473     {
1474         public Gtk.TreeViewColumn el;
1475         private Xcls_LeftProps  _this;
1476
1477
1478             // my vars (def)
1479
1480         // ctor
1481         public Xcls_keycol(Xcls_LeftProps _owner )
1482         {
1483             _this = _owner;
1484             _this.keycol = this;
1485             this.el = new Gtk.TreeViewColumn();
1486
1487             // my vars (dec)
1488
1489             // set gobject values
1490             this.el.title = "Name";
1491             this.el.resizable = true;
1492             var child_0 = new Xcls_keyrender( _this );
1493             child_0.ref();
1494             this.el.pack_start (  child_0.el , false );
1495
1496             // init method
1497
1498             this.el.add_attribute(_this.keyrender.el , "markup", 2 );
1499              this.el.add_attribute(_this.keyrender.el , "text", 1 );
1500         }
1501
1502         // user defined functions
1503     }
1504     public class Xcls_keyrender : Object
1505     {
1506         public Gtk.CellRendererText el;
1507         private Xcls_LeftProps  _this;
1508
1509
1510             // my vars (def)
1511
1512         // ctor
1513         public Xcls_keyrender(Xcls_LeftProps _owner )
1514         {
1515             _this = _owner;
1516             _this.keyrender = this;
1517             this.el = new Gtk.CellRendererText();
1518
1519             // my vars (dec)
1520
1521             // set gobject values
1522
1523             //listeners
1524             this.el.editing_started.connect( (  editable, path) => {
1525             
1526                  Gtk.TreeIter  iter;
1527                 _this.model.el.get_iter(out iter, new Gtk.TreePath.from_string(path));
1528                 GLib.Value gval;
1529                               
1530             
1531             
1532                  //   this.get('/LeftPanel.model').activePath  = path;
1533                 _this.model.el.get_value(iter,1, out gval);
1534                     var val = (string)gval;
1535                              
1536                     ((Gtk.Entry)editable).set_text(val);                 
1537             });
1538             this.el.edited.connect( (path, newtext) => {
1539                     print("Keyrender  - signal:edited\n");
1540                 
1541                 this.el.editable = false;
1542               
1543              
1544             
1545                     Gtk.TreeIter  iter;
1546                     _this.model.el.get_iter(out iter, new Gtk.TreePath.from_string(path));
1547                     GLib.Value gval;
1548                     
1549                      _this.model.el.get_value(iter,1, out gval);
1550                     var oldval = (string)gval;
1551                     
1552                      _this.model.el.get_value(iter,0, out gval);
1553                     var ktype = (string)gval;
1554                    
1555                     _this.model.el.set_value(iter, 1, newtext);
1556                     
1557                     if (oldval == newtext) {
1558                         return;
1559                     }
1560                     
1561                     
1562                     print("ktype: %s\n",ktype);
1563                     switch(ktype) {
1564                         case "listener":
1565                             var ov = _this.node.listeners.get(oldval);
1566                             _this.node.listeners.set(newtext, ov);
1567                             _this.node.listeners.unset(oldval);
1568                             
1569                             _this.updateIter(iter,  ktype, newtext, ov);
1570                             
1571                             break;
1572                         case "props":
1573                             var ov = _this.node.props.get(oldval);
1574                             _this.node.props.set(newtext, ov);
1575                             _this.node.props.unset(oldval);
1576                             _this.updateIter(iter,  ktype, newtext, ov);
1577                             break;
1578                      }
1579                      _this.changed();
1580                       
1581             });
1582         }
1583
1584         // user defined functions
1585     }
1586
1587
1588     public class Xcls_valcol : Object
1589     {
1590         public Gtk.TreeViewColumn el;
1591         private Xcls_LeftProps  _this;
1592
1593
1594             // my vars (def)
1595
1596         // ctor
1597         public Xcls_valcol(Xcls_LeftProps _owner )
1598         {
1599             _this = _owner;
1600             _this.valcol = this;
1601             this.el = new Gtk.TreeViewColumn();
1602
1603             // my vars (dec)
1604
1605             // set gobject values
1606             this.el.title = "Value";
1607             this.el.resizable = true;
1608             var child_0 = new Xcls_valrender( _this );
1609             child_0.ref();
1610             this.el.pack_start (  child_0.el , true );
1611
1612             // init method
1613
1614             {
1615                 
1616                 //     typeof(string),  // 0 key type
1617                 // typeof(string),  // 1 key
1618                 // typeof(string),  // 2 key (display)
1619                 // typeof(string),  // 3 value
1620                 // typeof(string)   // 4 value (display)
1621             
1622                 
1623                 this.el.add_attribute(_this.valrender.el , "text", 4 );
1624                 //this.el.add_attribute(_this.valrender.el , "sensitive", 4 );
1625                 //this.el.add_attribute(this.items[0].el , 'editable', 3 );
1626                       // this.el.set_cell_data_func(cell, age_cell_data_func, NULL, NULL);
1627             
1628              // this.get('/LeftPanel').editableColumn= this;
1629             }
1630         }
1631
1632         // user defined functions
1633     }
1634     public class Xcls_valrender : Object
1635     {
1636         public Gtk.CellRendererCombo el;
1637         private Xcls_LeftProps  _this;
1638
1639
1640             // my vars (def)
1641
1642         // ctor
1643         public Xcls_valrender(Xcls_LeftProps _owner )
1644         {
1645             _this = _owner;
1646             _this.valrender = this;
1647             this.el = new Gtk.CellRendererCombo();
1648
1649             // my vars (dec)
1650
1651             // set gobject values
1652             this.el.editable = false;
1653             this.el.text_column = 0;
1654             this.el.has_entry = true;
1655             var child_0 = new Xcls_valrendermodel( _this );
1656             child_0.ref();
1657             this.el.model = child_0.el;
1658
1659             //listeners
1660             this.el.editing_started.connect( ( editable, path) => {
1661                 //_this.editing = true;
1662                 print("editing started called\n");
1663                 if (!_this.allow_edit) {
1664                    
1665                      print("val - editing_Started\n");
1666                     this.el.editable = false; // make sure it's not editor...
1667                
1668                      
1669                     return;
1670                 }
1671                  _this.allow_edit =false;
1672                 
1673                
1674                  if (  this.el.has_entry ) {
1675                
1676                      Gtk.TreeIter  iter;
1677                     _this.model.el.get_iter(out iter, new Gtk.TreePath.from_string(path));
1678                     GLib.Value gval;
1679                                   
1680             
1681                   
1682                      //   this.get('/LeftPanel.model').activePath  = path;
1683                    _this.model.el.get_value(iter,3, out gval);
1684                 
1685             
1686                     var val = (string)gval;
1687                     var combo =        (Gtk.ComboBox)editable;
1688             
1689                     var entry =  (Gtk.Entry) combo.get_child();        
1690                     entry.set_text(val);
1691                 }
1692                
1693             });
1694             this.el.edited.connect( (path, newtext) => {
1695                 print("Valrender  - signal:edited\n");
1696               
1697                     this.el.editable = false;
1698             /*  
1699              m.set(iter, 
1700                             0, "listener",
1701                             1, miter.get_key(),
1702                             2, "<b>" + miter.get_key() + "</b>",
1703                             3, miter.get_value(),
1704                             4, display_value(short);
1705                         ); 
1706             
1707               */      
1708             
1709                     Gtk.TreeIter  iter;
1710                     _this.model.el.get_iter(out iter, new Gtk.TreePath.from_string(path));
1711                     GLib.Value gval;
1712                     
1713                      _this.model.el.get_value(iter,0, out gval);
1714                     var ktype = (string)gval;
1715                     
1716                     
1717                      _this.model.el.get_value(iter,3, out gval);
1718                     var oldval = (string)gval;
1719                     
1720                      _this.model.el.get_value(iter,1, out gval);
1721                     var key = (string)gval;
1722                     
1723                      
1724                     
1725                     switch(ktype) {
1726                         case "listener":
1727                             _this.node.listeners.set(key, newtext);
1728                             _this.updateIter(iter,ktype,key,newtext);
1729                             break;
1730                         case "props":
1731                             _this.node.props.set(key,newtext);
1732                             _this.updateIter(iter,ktype, key,newtext);                
1733                             break;
1734                      }
1735             //         _this.load(_this.file,_this.node);
1736                      _this.changed();
1737                       
1738             });
1739         }
1740
1741         // user defined functions
1742         public              void setOptions (string[] ar) {
1743               var m = _this.valrendermodel.el;
1744                 m.clear();
1745              Gtk.TreeIter iret;
1746             for (var i =0; i < ar.length; i++) {
1747                     m.append(out iret);
1748                     m.set_value(iret, 0, ar[i]);
1749             }
1750         
1751         }
1752     }
1753     public class Xcls_valrendermodel : Object
1754     {
1755         public Gtk.ListStore el;
1756         private Xcls_LeftProps  _this;
1757
1758
1759             // my vars (def)
1760
1761         // ctor
1762         public Xcls_valrendermodel(Xcls_LeftProps _owner )
1763         {
1764             _this = _owner;
1765             _this.valrendermodel = this;
1766             this.el = new Gtk.ListStore( 1, typeof(string) );
1767
1768             // my vars (dec)
1769
1770             // set gobject values
1771         }
1772
1773         // user defined functions
1774     }
1775
1776
1777
1778     public class Xcls_ContextMenu : Object
1779     {
1780         public Gtk.Menu el;
1781         private Xcls_LeftProps  _this;
1782
1783
1784             // my vars (def)
1785
1786         // ctor
1787         public Xcls_ContextMenu(Xcls_LeftProps _owner )
1788         {
1789             _this = _owner;
1790             _this.ContextMenu = this;
1791             this.el = new Gtk.Menu();
1792
1793             // my vars (dec)
1794
1795             // set gobject values
1796             var child_0 = new Xcls_MenuItem33( _this );
1797             child_0.ref();
1798             this.el.append (  child_0.el  );
1799             var child_1 = new Xcls_SeparatorMenuItem34( _this );
1800             child_1.ref();
1801             this.el.append (  child_1.el  );
1802             var child_2 = new Xcls_MenuItem35( _this );
1803             child_2.ref();
1804             this.el.append (  child_2.el  );
1805         }
1806
1807         // user defined functions
1808     }
1809     public class Xcls_MenuItem33 : Object
1810     {
1811         public Gtk.MenuItem el;
1812         private Xcls_LeftProps  _this;
1813
1814
1815             // my vars (def)
1816
1817         // ctor
1818         public Xcls_MenuItem33(Xcls_LeftProps _owner )
1819         {
1820             _this = _owner;
1821             this.el = new Gtk.MenuItem();
1822
1823             // my vars (dec)
1824
1825             // set gobject values
1826             this.el.label = "Edit";
1827
1828             //listeners
1829             this.el.activate.connect( ( )  =>{
1830               
1831                 var s = _this.view.el.get_selection();
1832                 Gtk.TreeIter iter;
1833                 Gtk.TreeModel model;
1834                 s.get_selected (out  model, out  iter);
1835                 _this.startEditingKey(model.get_path(iter));
1836             });
1837         }
1838
1839         // user defined functions
1840     }
1841
1842     public class Xcls_SeparatorMenuItem34 : Object
1843     {
1844         public Gtk.SeparatorMenuItem el;
1845         private Xcls_LeftProps  _this;
1846
1847
1848             // my vars (def)
1849
1850         // ctor
1851         public Xcls_SeparatorMenuItem34(Xcls_LeftProps _owner )
1852         {
1853             _this = _owner;
1854             this.el = new Gtk.SeparatorMenuItem();
1855
1856             // my vars (dec)
1857
1858             // set gobject values
1859         }
1860
1861         // user defined functions
1862     }
1863
1864     public class Xcls_MenuItem35 : Object
1865     {
1866         public Gtk.MenuItem el;
1867         private Xcls_LeftProps  _this;
1868
1869
1870             // my vars (def)
1871
1872         // ctor
1873         public Xcls_MenuItem35(Xcls_LeftProps _owner )
1874         {
1875             _this = _owner;
1876             this.el = new Gtk.MenuItem();
1877
1878             // my vars (dec)
1879
1880             // set gobject values
1881             this.el.label = "Delete";
1882
1883             //listeners
1884             this.el.activate.connect( ( )  =>{
1885                 _this.deleteSelected();
1886             });
1887         }
1888
1889         // user defined functions
1890     }
1891
1892
1893
1894
1895 }