git.roojs.org Git - app.Builder.js/blob - Builder/LeftPanel.js

   1 //<Script type="text/javascript">
   2 Gio = imports.gi.Gio;
   3 Gtk = imports.gi.Gtk;
   4 Gdk = imports.gi.Gdk;
   5 GLib = imports.gi.GLib;
   6 GObject = imports.gi.GObject;
   7 Pango = imports.gi.Pango ;
   8
   9 XObject = imports.XObject.XObject;
  10 console = imports.console;
  11
  12
  13 LeftPanelPopup  = imports.Builder.LeftPanelPopup.LeftPanelPopup;
  14 RightEditor     = imports.Builder.RightEditor.RightEditor;
  15 /**
  16  *
  17  * really the properties..
  18  */
  19
  20
  21 LeftPanel = new XObject({
  22
  23         xtype: Gtk.ScrolledWindow,
  24         smooth_scroll : true,
  25         pack : [ 'pack_end', true, true, 0 ],
  26         shadow_type : Gtk.ShadowType.IN,
  27
  28         init : function () {
  29             XObject.prototype.init.call(this);
  30             this.el.set_policy (Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC);
  31         },
  32         items : [
  33             {
  34                 id : 'view',
  35
  36                 xtype : Gtk.TreeView,
  37
  38                 tooltip_column : 1,
  39                 headers_visible :   false ,
  40                 enable_tree_lines :  true ,
  41
  42                 init : function () {
  43                     XObject.prototype.init.call(this);
  44
  45                     this.selection = this.el.get_selection();
  46                     this.selection.set_mode( Gtk.SelectionMode.SINGLE);
  47
  48
  49                     var description = new Pango.FontDescription.c_new();
  50                     description.set_size(8000);
  51                     this.el.modify_font(description);
  52                 },
  53                 listeners : {
  54
  55
  56                     'button-press-event' : function(tv, ev) {
  57                         if (ev.type != Gdk.EventType.BUTTON_PRESS  || ev.button.button != 3) {
  58                             Seed.print("click" + ev.type);
  59                             return false;
  60                         }
  61
  62
  63                         var res = { };
  64                         this.el.get_path_at_pos(ev.button.x,ev.button.y, res);
  65
  66                         if (res.column.title == 'value') {
  67                             return false;
  68                         }
  69                         if (!LeftPanelPopup.el) LeftPanelPopup.init();
  70                         LeftPanelPopup.el.set_screen(Gdk.Screen.get_default());
  71                         LeftPanelPopup.el.show_all();
  72                         LeftPanelPopup.el.popup(null, null, null, null, 3, ev.button.time);
  73                         Seed.print("click:" + res.column.title);
  74                         return false;
  75
  76                     }
  77                 },
  78                 items : [
  79
  80                     {
  81                         id : 'model',
  82                         pack : [ 'set_model' ],
  83                         xtype : Gtk.ListStore,
  84
  85                         init : function ()
  86                         {
  87                             XObject.prototype.init.call(this);
  88                             this.el.set_column_types ( 5, [
  89                                 GObject.TYPE_STRING,  // 0 real key
  90                                 GObject.TYPE_STRING, // 1 real value
  91                                  GObject.TYPE_STRING,  // 2 visable key
  92                                  GObject.TYPE_STRING, // 3 visable value
  93                                  GObject.TYPE_STRING, // 4 need to store type of!!!
  94
  95                             ]);
  96
  97
  98
  99                         },
 100                         toShort: function(str) {
 101                             var a = typeof(str) == 'string' ? str.split("\n") : [];
 102                             return a.length > 1 ? a[0] + '....' : '' + str;
 103                         },
 104                         load : function (ar)
 105                         {
 106                             this.el.clear();
 107
 108                             RightEditor.el.hide();
 109                             if (ar === false) {
 110                                 return ;
 111                             }
 112
 113                             // sort!!!?
 114                             var iter = new Gtk.TreeIter();
 115                             for (var i in ar) {
 116                                 if (typeof(ar[i]) == 'object') {
 117                                     continue;
 118                                 }
 119                                 this.el.append(iter);
 120                                 this.el.set_value(iter, 0, i);
 121                                 this.el.set_value(iter, 1, '' + ar[i]);
 122                                 this.el.set_value(iter, 2, i);
 123                                 this.el.set_value(iter, 3, this.toShort(ar[i]));
 124                                 this.el.set_value(iter, 4, typeof(ar[i]));
 125                             }
 126                             ar.listeners = ar.listeners || {};
 127                             for (var i in ar.listeners ) {
 128                                 this.el.append(iter);
 129                                 this.el.set_value(iter, 0, '!'+  i  );
 130                                 this.el.set_value(iter, 1, '' + ar.listeners[i]);
 131                                 this.el.set_value(iter, 2, '<b>'+ i + '</b>');
 132
 133                                 this.el.set_value(iter, 3, '' + this.toShort(ar.listeners[i]));
 134                                 this.el.set_value(iter, 4, typeof(ar[i]));
 135                             }
 136
 137                         },
 138
 139
 140
 141                         add : function( info ) {
 142                             // info includes key, val, skel, etype..
 143                              console.dump(info);
 144                             type = info.type.toLowerCase();
 145                             var data = this.toJS();
 146
 147                             if (info.etype == 'events') {
 148                                 data.listeners = data.listeners || { };
 149                                 if (typeof(data.listeners[info.key]) != 'undefined') {
 150                                     return; //already set!
 151                                 }
 152                             } else {
 153                                 if (typeof(data[info.key]) != 'undefined') {
 154                                     return;
 155                                 }
 156                             }
 157
 158                             if (typeof(info.val) == 'undefined') {
 159
 160                                 info.val = '';
 161                                 if (info.type == 'boolean') {
 162                                     info.val = true;
 163                                 }
 164                                 if (type == 'number') {
 165                                     info.val = 0;
 166                                 }
 167                                 // utf8 == string..
 168
 169
 170                             }
 171                             if (info.etype == 'events') {
 172
 173                                 data.listeners[info.key] = info.val;
 174                             } else {
 175                                 data[info.key] = info.val;
 176                             }
 177
 178
 179                             this.load(data);
 180                             var LeftTree        = imports.Builder.LeftTree.LeftTree;
 181                             LeftTree.get('model').changed(data, true);
 182
 183
 184                         },
 185                         deleteSelected : function()
 186                         {
 187                             var data = this.toJS();
 188                             var iter = new Gtk.TreeIter();
 189                             var s = LeftPanel.get('view').selection;
 190                             s.get_selected(this.el, iter);
 191
 192
 193                             var gval = new GObject.Value('');
 194                             LeftPanel.get('model').el.get_value(iter, 0 ,gval);
 195
 196                             var val = gval.value;
 197                             if (val[0] == '!') {
 198                                 // listener..
 199                                 if (!data.listeners || typeof(data.listeners[  val.substring(1)]) == 'undefined') {
 200                                     return;
 201                                 }
 202                                 delete data.listeners[  val.substring(1)];
 203                                 if (!XObject.keys(data.listeners).length) {
 204                                     delete data.listeners;
 205                                 }
 206
 207                             } else {
 208                                 if (typeof(data[val]) == 'undefined') {
 209                                     return;
 210                                 }
 211                                 delete data[val];
 212                             }
 213
 214
 215                             this.load(data);
 216                             var LeftTree        = imports.Builder.LeftTree.LeftTree;
 217                             LeftTree.get('model').changed(data, true);
 218
 219                         },
 220
 221
 222
 223                         activeIter : false,
 224                         changed : function(str, doRefresh)
 225                         {
 226                             if (!this.activeIter) {
 227                                 return;
 228                             }
 229                             this.el.set_value(this.activeIter, 1, str);
 230                             this.el.set_value(this.activeIter, 3, '' + this.toShort(str));
 231                             // update the tree...
 232                             var LeftTree        = imports.Builder.LeftTree.LeftTree;
 233                             LeftTree.get('model').changed(this.toJS(), doRefresh);
 234                         },
 235                         toJS: function()
 236                         {
 237                             var iter = new Gtk.TreeIter();
 238                             LeftPanel.get('model').el.get_iter_first(iter);
 239                             var ar = {};
 240
 241                             while (true) {
 242
 243                                 var k = this.getValue(iter, 0);
 244                                 Seed.print(k);
 245                                 if (k[0] == '!') {
 246                                     ar.listeners = ar.listeners || {};
 247                                     ar.listeners[  k.substring(1)] = this.getValue(iter, 1);
 248
 249                                 } else {
 250                                     ar[ k ] = this.getValue(iter, 1);
 251                                 }
 252
 253                                 if (! LeftPanel.get('model').el.iter_next(iter)) {
 254                                     break;
 255                                 }
 256                             }
 257                                 Seed.print(JSON.stringify(ar));
 258                             return ar;
 259                             // convert the list into a json string..
 260
 261
 262                         },
 263                         /** get's a value, and tries to use type column to work out what type */
 264                         getValue: function (iter, col) {
 265                             var gval = new GObject.Value('');
 266                             LeftPanel.get('model').el.get_value(iter, col ,gval);
 267                             var val = '' + gval.value;
 268                             if (col != 1) {
 269                                 return val;
 270                             }
 271                             gval = new GObject.Value('');
 272                             LeftPanel.get('model').el.get_value(iter,4  ,gval);
 273                             switch(gval.value) {
 274                                 case 'number':
 275                                     return parseFloat(val);
 276                                 case 'boolean':
 277                                     return val == 'true' ? true : false;
 278                                 default:
 279                                     return val;
 280                             }
 281
 282                         },
 283
 284                         editSelected: function()
 285                         {
 286                             var iter = new Gtk.TreeIter();
 287                             var s = LeftPanel.get('view').selection;
 288                             s.get_selected(LeftPanel.get('model').el, iter);
 289                             var m = LeftPanel.get('model');
 290
 291                             var gval = new GObject.Value('');
 292                             m.el.get_value(iter, 0 ,gval);
 293                             var val = '' + gval.value;
 294
 295                             gval = new GObject.Value('');
 296                             m.el.get_value(iter, 1 ,gval);
 297                             var rval = gval.value;
 298                             var activePath = m.el.get_path(iter).to_string();
 299                             m.activePath = activePath ;
 300                             // was activeIter...
 301                             //  not listener...
 302
 303                             var showEditor = false;
 304
 305                             if (val[0] == '!') {
 306                                 showEditor = true;
 307                             }
 308                             if (val[0] == '|') {
 309                                 if (rval.match(/function/g) || rval.match(/\n/g)) {
 310                                     showEditor = true;
 311                                 }
 312                             }
 313                             if (showEditor) {
 314
 315                                 m.activePath = false;
 316                                 GLib.timeout_add(0, 1, function() {
 317                                     //   Gdk.threads_enter();
 318                                     RightEditor.el.show();
 319                                     RightEditor.get('view').load( rval );
 320
 321                                     e.editing_done();
 322                                     e.remove_widget();
 323                                     m.activePath = activePath ;
 324
 325                              //       Gdk.threads_leave();
 326                                     return false;
 327                                 });
 328                                 return;
 329                             }
 330
 331                             RightEditor.el.hide();
 332
 333                             var type = m.getValue(iter,4);
 334
 335                             // toggle boolean
 336                             if (type == 'boolean') {
 337                                 val = ! m.getValue(iter,1);
 338
 339
 340                                 LeftPanel.get('model').activeIter = false;
 341                                 GLib.timeout_add(0, 1, function() {
 342                                     //   Gdk.threads_enter();
 343
 344                                     e.editing_done();
 345                                     e.remove_widget();
 346                                     m.activePath = activePath ;
 347                                     m.changed(''+val,true);
 348
 349
 350                                     return false;
 351                                 });
 352                             }
 353
 354                              // otherwise we are going to show the text editor..
 355
 356                             }
 357
 358                             //r.stop_editing(true);
 359                         }
 360                         }
 361
 362
 363                     },
 364
 365                     {
 366
 367                         xtype: Gtk.TreeViewColumn,
 368                         pack : ['append_column'],
 369                         title : 'key',
 370                         init : function ()
 371                         {
 372                             XObject.prototype.init.call(this);
 373                             this.el.add_attribute(this.items[0].el , 'markup', 2 );
 374                         },
 375                         items : [
 376                             {
 377                                 xtype : Gtk.CellRendererText,
 378                                 pack : ['pack_start'],
 379                             }
 380                         ]
 381                     },
 382
 383                     {
 384
 385                         xtype: Gtk.TreeViewColumn,
 386                         pack : ['append_column'],
 387                         title : 'value',
 388                         init : function ()
 389                         {
 390                             XObject.prototype.init.call(this);
 391                             this.el.add_attribute(this.items[0].el , 'text', 3 );
 392
 393                         },
 394                         items : [
 395
 396
 397                             {
 398
 399                                 xtype : Gtk.CellRendererText,
 400                                 pack : ['pack_start'],
 401                                 editable : true,
 402
 403
 404
 405                                 listeners : {
 406
 407                                     edited : function(r,p, t) {
 408                                         LeftPanel.get('model').changed(t, true);
 409                                         LeftPanel.get('model').activeIter = false;
 410
 411                                     },
 412
 413                                     'editing-started' : function(r, e, p) {
 414
 415                                         var iter = new Gtk.TreeIter();
 416                                         var s = LeftPanel.get('view').selection;
 417                                         s.get_selected(LeftPanel.get('model').el, iter);
 418
 419
 420                                         var gval = new GObject.Value('');
 421                                         LeftPanel.get('model').el.get_value(iter, 0 ,gval);
 422                                         var val = '' + gval.value;
 423
 424                                         gval = new GObject.Value('');
 425                                         LeftPanel.get('model').el.get_value(iter, 1 ,gval);
 426                                         var rval = gval.value;
 427
 428                                         LeftPanel.get('model').activeIter = iter;
 429                                         //  not listener...
 430
 431                                         var showEditor = false;
 432
 433                                         if (val[0] == '!') {
 434                                             showEditor = true;
 435                                         }
 436                                         if (val[0] == '|') {
 437                                             if (rval.match(/function/g) || rval.match(/\n/g)) {
 438                                                 showEditor = true;
 439                                             }
 440                                         }
 441
 442                                         if (!showEditor) {
 443                                             RightEditor.el.hide();
 444
 445                                             var type = LeftPanel.get('model').getValue(iter,4);
 446
 447                                             // toggle boolean
 448                                             if (type == 'boolean') {
 449                                                 val = ! LeftPanel.get('model').getValue(iter,1);
 450
 451
 452                                                 LeftPanel.get('model').activeIter = false;
 453                                                 GLib.timeout_add(0, 1, function() {
 454                                                     //   Gdk.threads_enter();
 455
 456                                                     e.editing_done();
 457                                                     e.remove_widget();
 458                                                     LeftPanel.get('model').activeIter = iter;
 459                                                     LeftPanel.get('model').changed(''+val,true);
 460
 461
 462                                                     return false;
 463                                                 });
 464                                             }
 465
 466                                             return;
 467                                         }
 468                                         LeftPanel.get('model').activeIter = false;
 469                                         GLib.timeout_add(0, 1, function() {
 470                                             //   Gdk.threads_enter();
 471                                             RightEditor.el.show();
 472                                             RightEditor.get('view').load( rval );
 473
 474                                             e.editing_done();
 475                                             e.remove_widget();
 476                                             LeftPanel.get('model').activeIter = iter;
 477
 478                                      //       Gdk.threads_leave();
 479                                             return false;
 480                                         });
 481                                         //r.stop_editing(true);
 482                                     }
 483                                 },
 484
 485                             }
 486                         ]
 487                     }
 488
 489                 ]
 490             }
 491         ]
 492
 493     }
 494 );
 495
 496
 497