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

   1 //<script type="text/javascript">
   2 Gio = imports.gi.Gio;
   3 Gtk = imports.gi.Gtk;
   4 Gdk = imports.gi.Gdk;
   5 GObject = imports.gi.GObject;
   6  GLib= imports.gi.GLib;
   7
   8 /**
   9 * we use a hidden window to render the created dialog...
  10 * then use snapshot to render it to an image...
  11 *
  12 */
  13
  14
  15 XObject = imports.XObject.XObject;
  16 File = imports.File.File;
  17 console = imports.console;
  18
  19 LeftTree = imports.Builder.LeftTree.LeftTree ;
  20 LeftPanel = imports.Builder.LeftPanel.LeftPanel;
  21  //console.dump(imports.Builder.LeftTree);
  22  //Seed.quit();
  23
  24 RightGtkView = new XObject({
  25         xtype : Gtk.VBox,
  26         lastSrc : '',
  27         pack : [ 'append_page', new Gtk.Label({ label : "Gtk View" })  ],
  28         items : [
  29
  30             {
  31                 xtype: Gtk.HBox,
  32                 pack : [ 'pack_start', false, true, 0 ],
  33                 items : [
  34                     {
  35
  36
  37                         xtype: Gtk.Button,
  38                         label : 'Show in New Window',
  39                         pack : [ 'pack_start', false, false, 0 ],
  40                         listeners : {
  41                             // pressed...
  42                             'button-press-event' : function(w, ev ){
  43                                 /// dump..
  44                                 RightGtkView.showInWindow();
  45                                 return true;
  46                                 // show the MidPropTree..
  47                             }
  48
  49                         }
  50                     }
  51                 ]
  52             },
  53             {
  54
  55
  56                 renderedData : false,
  57                 xtype: Gtk.ScrolledWindow,
  58                 id: 'view-sw',
  59                 smooth_scroll : true,
  60                 shadow_type : Gtk.ShadowType.IN ,
  61                 init : function() {
  62                     XObject.prototype.init.call(this);
  63
  64                     this.el.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC);
  65                 },
  66
  67                 items : [
  68                     {
  69
  70                         id : 'view-vbox',
  71                         xtype : Gtk.Fixed,
  72                         init : function () {
  73                             XObject.prototype.init.call(this);
  74                             //this.el.set_hadjustment(this.parent.el.get_hadjustment());
  75                             //this.el.set_vadjustment(this.parent.el.get_vadjustment());
  76
  77                         },
  78                         pack : 'add_with_viewport',
  79                         items: [
  80                             {
  81                                 id : 'view',
  82                                 xtype : Gtk.VBox,
  83                                 /*
  84                                 xtype : function() {
  85                                     return new Gtk.Image.from_stock (Gtk.STOCK_HOME, 100)
  86
  87                                 },
  88                                 */
  89                                 pack : 'put,15,15',
  90                                 ready : false,
  91                                 init : function() {
  92                                     XObject.prototype.init.call(this);
  93                                     // fixme!
  94
  95                                     Gtk.drag_dest_set
  96                                     (
  97                                             this.el,              /* widget that will accept a drop */
  98                                             Gtk.DestDefaults.MOTION  | Gtk.DestDefaults.HIGHLIGHT,
  99                                             null,            /* lists of target to support */
 100                                             0,              /* size of list */
 101                                             Gdk.DragAction.COPY         /* what to do with data after dropped */
 102                                     );
 103
 104                                    // print("RB: TARGETS : " + LeftTree.atoms["STRING"]);
 105                                     Gtk.drag_dest_set_target_list(this.el, LeftTree.targetList);
 106                                     //Gtk.drag_dest_add_text_targets(this.el);
 107                                 },
 108                                 listeners : {
 109
 110
 111
 112                                     "drag-leave" : function () {
 113                                         Seed.print("TARGET: drag-leave");
 114                                         // stop monitoring of mouse montion in rendering..
 115                                         return true;
 116                                     },
 117                                     'drag-motion' : function (w, ctx,  x,   y,   time, ud)
 118                                     {
 119
 120
 121                                        // console.log('DRAG MOTION');
 122                                         // status:
 123                                         // if lastCurrentNode == this.currentNode.. -- don't change anything..
 124
 125
 126                                         // A) find out from drag all the places that node could be dropped.
 127                                         var src = Gtk.drag_get_source_widget(ctx);
 128                                         if (!src.dropList) {
 129                                             Gdk.drag_status(ctx, 0, time);
 130                                             return true;
 131                                         }
 132                                         // b) get what we are over.. (from activeNode)
 133                                         // tree is empty.. - list should be correct..
 134                                         if (!LeftTree.get('model').currentTree) {
 135                                             Gdk.drag_status(ctx, Gdk.DragAction.COPY,time);
 136                                             return true;
 137
 138                                         }
 139                                         // c) ask tree where it should be dropped... - eg. parent.. (after node ontop)
 140                                         var activeNode = this.getActiveNode(x, y);
 141
 142
 143                                         var tg = LeftTree.get('model').findDropNode(activeNode, src.dropList);
 144                                         console.dump(tg);
 145                                         if (!tg.length) {
 146                                             Gdk.drag_status(ctx, 0,time);
 147                                             LeftTree.get('view').highlight(false);
 148                                             return true;
 149                                         }
 150
 151                                         // if we have a target..
 152                                         // -> highlight it! (in browser)
 153                                         // -> highlight it! (in tree)
 154
 155                                         Gdk.drag_status(ctx, Gdk.DragAction.COPY,time);
 156                                         LeftTree.get('view').highlight(tg);
 157                                         this.targetData = tg;
 158                                         // for tree we should handle this...
 159                                         return true;
 160
 161                                     },
 162                                     "drag-drop"  : function (w, ctx,x,y,time, ud)
 163                                     {
 164
 165                                         Seed.print("TARGET: drag-drop");
 166                                         is_valid_drop_site = true;
 167
 168
 169                                         Gtk.drag_get_data
 170                                         (
 171                                                 w,         /* will receive 'drag-data-received' signal */
 172                                                 ctx,        /* represents the current state of the DnD */
 173                                                 LeftTree.atoms["STRING"],    /* the target type we want */
 174                                                 time            /* time stamp */
 175                                         );
 176
 177
 178                                         /* No target offered by source => error */
 179
 180
 181                                         return  is_valid_drop_site;
 182
 183
 184                                     },
 185                                     "drag-data-received" : function (w, ctx,  x,  y, sel_data,  target_type,  time, ud)
 186                                     {
 187                                         Seed.print("GtkView: drag-data-received");
 188                                         var delete_selection_data = false;
 189                                         var dnd_success = false;
 190                                         /* Deal with what we are given from source */
 191                                         if( sel_data && sel_data.length ) {
 192
 193                                             if (ctx.action == Gdk.DragAction.ASK)  {
 194                                                 /* Ask the user to move or copy, then set the ctx action. */
 195                                             }
 196
 197                                             if (ctx.action == Gdk.DragAction.MOVE) {
 198                                                 delete_selection_data = true;
 199                                             }
 200                                             var source = Gtk.drag_get_source_widget(ctx);
 201
 202                                             Seed.print("Browser: source.DRAGDATA? " + source.dragData);
 203                                             if (this.targetData) {
 204                                                 Seed.print(this.targetData);
 205                                                 LeftTree.get('model').dropNode(this.targetData,  source.dragData);
 206                                             }
 207
 208
 209
 210                                             dnd_success = true;
 211
 212                                         }
 213
 214                                         if (dnd_success == false)
 215                                         {
 216                                                 Seed.print ("DnD data transfer failed!\n");
 217                                         }
 218
 219                                         Gtk.drag_finish (ctx, dnd_success, delete_selection_data, time);
 220                                         return true;
 221                                     }
 222
 223                                    //'line-mark-activated' : line_mark_activated,
 224
 225
 226                                 },
 227
 228                                 getActiveNode : function(x,y)
 229                                 {
 230                                    // workout what node is here..
 231                                     return '0'; // top..
 232                                 }
 233                             }
 234                         ]
 235                     }
 236                 ]
 237             }
 238
 239         ],
 240
 241         showInWindow: function ()
 242         {
 243
 244
 245             var src= this.buildJS(this.get('/LeftTree.model').toJS()[0], true);
 246
 247
 248             this.get('/Terminal').feed("Running\n");
 249
 250             //var x = new imports.sandbox.Context();
 251             //x.add_globals();
 252             //print(src);
 253             try {
 254                 Seed.check_syntax('var e = ' + src);
 255               //  x.eval(src);
 256             } catch( e) {
 257                 this.get('/Terminal').feed(e.message || e.toString() + "\n");
 258                 this.get('/Terminal').feed(console._dump(e)+"\n");
 259                 if (e.line) {
 260                     var lines = src.split("\n");
 261                     var start = Math.max(0, e.line - 10);
 262                     var end = Math.min(lines.length, e.line + 10);
 263                     for (var i =start ; i < end; i++) {
 264                         if (i == e.line) {
 265                             this.get('/Terminal').feed(">>>>>" + lines[i] + "\n");
 266
 267
 268                             continue;
 269                         }
 270
 271                         this.get('/Terminal').feed(lines[i] + "\n");
 272                     }
 273
 274                 }
 275
 276                 return;
 277             }
 278             this.get('/BottomPane').el.set_current_page(1);
 279             this.get('/Terminal').el.fork_command( null , [], [], "/tmp", false,false,false);
 280             var cmd = "/usr/bin/seed /tmp/BuilderGtkView.js\n";
 281             this.get('/Terminal').el.feed_child(cmd, cmd.length);
 282             //'/usr/bin/seed',  [ '/tmp/BuilderGtkView.js'], [], "/tmp", false,false,false);
 283             /*
 284             var _top = x.get_global_object()._top;
 285
 286             _top.el.set_screen(Gdk.Screen.get_default()); // just in case..
 287             _top.el.show_all();
 288             if (_top.el.popup) {
 289                 _top.el.popup(null, null, null, null, 3, null);
 290             }
 291             */
 292         },
 293
 294         buildJS: function(data,withDebug)
 295         {
 296             var i = [ 'Gtk', 'Gdk', 'Pango', 'GLib', 'Gio', 'GObject', 'GtkSource', 'WebKit', 'Vte' ];
 297             var src = "";
 298             i.forEach(function(e) {
 299                 src += e+" = imports.gi." + e +";\n";
 300             });
 301
 302             if (withDebug) {
 303                src+= "imports.searchPath.push(" + JSON.stringify(GLib.path_get_dirname(__script_path__)) + ");\n";
 304             }
 305
 306             src += "console = imports.console;\n"; // path?!!?
 307             src += "XObject = imports.XObject.XObject;\n"; // path?!!?
 308             src += "XObject.cache = {};\n"; // reset cache!
 309             if (withDebug) {
 310
 311
 312
 313                 src += "Gtk.init(null,null);\n";
 314             }
 315             if (withDebug) {
 316                 src += "XObject.debug=true;\n";
 317             }
 318
 319             this.withDebug = withDebug;
 320             src += '_top=new XObject('+ this.mungeToString(data) + ')\n;';
 321             src += '_top.init();\n';
 322             if (withDebug) {
 323                 src += "_top.el.show_all();\n";
 324                 src += "Gtk.main();\n";
 325             }
 326             File.write('/tmp/BuilderGtkView.js', src);
 327             print("Test code  in /tmp/BuilderGtkView.js");
 328             this.lastSrc = src;
 329             return src;
 330         },
 331
 332         renderJS : function(data, withDebug)
 333         {
 334             // can we mess with data?!?!?
 335
 336             /**
 337              * first effort..
 338              * sandbox it? - nope then will have dificulting passing. stuff aruond..
 339              *
 340              */
 341             if (!data) {
 342                  return;
 343             }
 344             this.withDebug = false;
 345
 346             if (this.renderedEl) {
 347                 this.get('view').el.remove(this.renderedEl);
 348                 this.renderedEl.destroy();
 349                 this.renderedEl = false;
 350             }
 351
 352             var tree =  this.get('/LeftTree.model').toJS(false,true)[0];
 353             // in theory tree is actually window..
 354             this.renderedEl = this.viewAdd(tree.items[0], this.get('view').el);
 355
 356             this.renderedEl.set_size_request(
 357                 tree.default_width || 600,
 358                 tree.default_height || 400
 359             );
 360             this.get('view').el.show_all();
 361
 362             return;
 363
 364
 365             var src = this.buildJS(data,withDebug);
 366             var x = new imports.sandbox.Context();
 367             x.add_globals();
 368             //x.get_global_object().a = "hello world";
 369
 370             try {
 371                 Seed.check_syntax('var e = ' + src);
 372                 x.eval(src);
 373             } catch( e) {
 374                 //if (!withDebug) {
 375                 //   return this.renderJS(data,true);
 376                // }
 377                 print(e.message || e.toString());
 378                 console.dump(e);
 379                 return;
 380             }
 381
 382             var r = new Gdk.Rectangle();
 383             var _top = x.get_global_object()._top;
 384
 385             _top.el.set_screen(Gdk.Screen.get_default()); // just in case..
 386             _top.el.show_all();
 387
 388
 389             if (_top.el.popup) {
 390                 _top.el.popup(null, null, null, null, 3, null);
 391             }
 392
 393
 394
 395             var pb = _top.items[0].el.get_snapshot(r);
 396             _top.el.hide();
 397             if (!pb) {
 398                 return;
 399             }
 400
 401             _top.el.destroy();
 402             x._top = false;
 403             var Window = imports.Builder.Window.Window;
 404             var gc = new Gdk.GC.c_new(Window.el.window);
 405
 406                 // 10 points all round..
 407             var full = new Gdk.Pixmap.c_new (Window.el.window, r.width+20, r.height+20, pb.get_depth());
 408             // draw a white background..
 409            // gc.set_rgb_fg_color({ red: 0, white: 0, black : 0 });
 410             Gdk.draw_rectangle(full, gc, true, 0, 0, r.width+20, r.height+20);
 411             // paint image..
 412             Gdk.draw_drawable (full, gc, pb, 0, 0, 10, 10, r.width, r.height);
 413             // boxes..
 414             //gc.set_rgb_fg_color({ red: 255, white: 255, black : 255 });
 415             Gdk.draw_rectangle(full, gc, true, 0, 0, 10, 10);
 416             this.get('view').el.set_from_pixmap(full, null);
 417             //this.get('view-vbox').el.set_size_request( r.width+20, r.height+20);
 418             //var img = new Gtk.Image.from_file("/home/alan/solarpanels.jpeg");
 419
 420
 421
 422         },
 423         mungeToString:  function(obj, isListener, pad)
 424         {
 425             pad = pad || '';
 426             var keys = [];
 427             var isArray = false;
 428             isListener = isListener || false;
 429
 430             // am I munging a object or array...
 431             if (obj.constructor.toString() === Array.toString()) {
 432                 for (var i= 0; i < obj.length; i++) {
 433                     keys.push(i);
 434                 }
 435                 isArray = true;
 436             } else {
 437                 for (var i in obj) {
 438                     keys.push(i);
 439                 }
 440             }
 441
 442
 443             var els = [];
 444             var skip = [];
 445             if (!isArray &&
 446                     typeof(obj['|xns']) != 'undefined' &&
 447                     typeof(obj['xtype']) != 'undefined'
 448                 ) {
 449                     els.push('xtype: '+ obj['|xns'] + '.' + obj['xtype']);
 450                     skip.push('|xns','xtype');
 451                 }
 452
 453             var _this = this;
 454
 455
 456
 457             keys.forEach(function(i) {
 458                 var el = obj[i];
 459                 if (!isArray && skip.indexOf(i) > -1) {
 460                     return;
 461                 }
 462                 if (isListener) {
 463                     if (!_this.withDebug) {
 464                         // do not write listeners unless we are debug mode.
 465                         return;
 466                     }
 467                     //if (obj[i].match(new RegExp("Gtk.main" + "_quit"))) { // we can not handle this very well..
 468                     //    return;
 469                    // }
 470                     var str= ('' + obj[i]).replace(/^\s+|\s+$/g,"");
 471                     var lines = str.split("\n");
 472                     if (lines.length > 1) {
 473                         str = lines.join("\n" + pad);
 474                     }
 475                     els.push(JSON.stringify(i) + ":" + str);
 476                     return;
 477                 }
 478                 if (i[0] == '|') {
 479                     // does not hapepnd with arrays..
 480                     if (typeof(el) == 'string' && !obj[i].length) { //skip empty.
 481                         return;
 482                     }
 483                     // this needs to go...
 484                     //if (typeof(el) == 'string'  && obj[i].match(new RegExp("Gtk.main" + "_quit"))) { // we can not handle this very well..
 485                     //    return;
 486                     //}
 487
 488                     var str= ('' + obj[i]).replace(/^\s+|\s+$/g,"");;
 489                     var lines = str.split("\n");
 490                     if (lines.length > 1) {
 491                         str = lines.join("\n" + pad);
 492                     }
 493
 494                     els.push(JSON.stringify(i.substring(1)) + ":" + str);
 495                     return;
 496                 }
 497                 var left = isArray ? '' : (JSON.stringify(i) + " : " )
 498                 if (typeof(el) == 'object') {
 499                     els.push(left + _this.mungeToString(el, i == 'listeners', pad + '    '));
 500                     return;
 501                 }
 502                 els.push(JSON.stringify(i) + ":" + JSON.stringify(obj[i]));
 503             });
 504             var spad = pad.substring(0, pad.length-4);
 505             return (isArray ? '[' : '{') + "\n" +
 506                 pad  + els.join(",\n" + pad ) +
 507                 "\n" + spad + (isArray ? ']' : '}');
 508
 509
 510
 511         },
 512
 513         buildView : function()
 514         {
 515
 516
 517         },
 518         viewAdd : function(item, par)
 519         {
 520             // does something similar to xobject..
 521             item.pack = (typeof(item.pack) == 'undefined') ?  'add' : item.pack;
 522
 523             if (item.pack===false || item.pack === 'false') {  // no ;
 524                 return;
 525             }
 526             print("CREATE: " + item['|xns'] + '.' + item['xtype']);
 527             var ns = imports.gi[item['|xns']];
 528             var ctr = ns[item['xtype']];
 529             var ctr_args = { };
 530             for(var k in item) {
 531                 var kv = item[k];
 532                 if (typeof(kv) == 'object' || typeof(kv) == 'function') {
 533                     continue;
 534                 }
 535                 if (
 536                     k == 'pack' ||
 537                     k == 'items' ||
 538                     k == 'id' ||
 539                     k == 'xtype' ||
 540                     k == 'xdebug' ||
 541                     k == 'xns' ||
 542                     k == '|xns'
 543                 ) {
 544                     continue;
 545                 }
 546                 ctr_args[k] = kv;
 547
 548             }
 549
 550
 551             var el = new ctr(ctr_args);
 552
 553             print("PACK");
 554             console.dump(item.pack);
 555
 556
 557
 558
 559             var args = [];
 560             var pack_m  = false;
 561             if (typeof(item.pack) == 'string') {
 562
 563                 item.pack.split(',').forEach(function(e, i) {
 564
 565                     if (e == 'false') { args.push( false); return; }
 566                     if (e == 'true') {  args.push( true);  return; }
 567                     if (!isNaN(parseInt(e))) { args.push( parseInt(e)); return; }
 568                     args.push(e);
 569                 });
 570                 //print(args.join(","));
 571
 572                 pack_m = args.shift();
 573             } else {
 574                 pack_m = item.pack.shift();
 575                 args = item.pack;
 576             }
 577
 578             // handle error.
 579             if (pack_m && typeof(par[pack_m]) == 'undefined') {
 580                 Seed.print('pack method not available : ' + item.xtype + '.' +  pack_m);
 581                 return;
 582             }
 583
 584             console.dump(args);
 585             args.unshift(el);
 586             //if (XObject.debug) print(pack_m + '[' + args.join(',') +']');
 587             //Seed.print('args: ' + args.length);
 588             if (pack_m) {
 589                 par[pack_m].apply(par, args);
 590             }
 591
 592             var _this = this;
 593             item.items = item.items || [];
 594             item.items.forEach(function(ch) {
 595                 _this.viewAdd(ch, el);
 596             });
 597
 598
 599
 600             // add the signal handlers.
 601             // is it a widget!?!!?
 602
 603
 604             try {
 605
 606
 607                 el.signal.expose_event.connect(XObject.createDelegate(this.widgetExposeEvent, this, [ item  ], true));
 608                 el.signal.drag_motion.connect(XObject.createDelegate(this.widgetDragMotionEvent, this,[ item  ], true));
 609                 el.signal.drag_drop.connect(XObject.createDelegate(this.widgetDragDropEvent, this, [ item  ], true));
 610                 el.signal.button_press_event.connect(XObject.createDelegate(this.widgetPressEvent, this, [ item  ], true ));
 611             } catch(e) {
 612                 // ignore!
 613                }
 614
 615
 616
 617             return el;
 618
 619         },
 620          widgetExposeEvent : function()
 621         {
 622             print("WIDGET EXPOSE"); // draw highlight??
 623             return false;
 624         },
 625         widgetDragMotionEvent : function()
 626         {
 627             print("WIDGET DRAGMOTION");
 628             return true;
 629         },
 630         widgetDragDropEvent : function()
 631         {
 632             print("WIDGET DRAGDROP");
 633             return true;
 634         },
 635         widgetPressEvent : function(w,e,u,d)
 636         {
 637             print("WIDGET PRESs" + d.xtreepath );
 638
 639             return false;
 640         }
 641
 642
 643
 644     }
 645
 646
 647 );
 648