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