tools/build_gtk_tree.js
[app.Builder.js] / XObject.js
1 //<script type="text/javascript">
2 GIRepository = imports.gi.GIRepository;
3 GObject = imports.gi.GObject;
4 /**
5  * XObject
6  * Yet another attempt to create a usable object construction library for seed..
7  * 
8  * Why is this useful?
9  * A) It turns rather messy code into a tree structure, making it easy to find code relating to 
10  *    an interface element
11  * B) In theory it should be gjs/Seed compatible..
12  * C) It provides getElementById style lookups for elements.
13  * D) It provides classic OO constructors for Javascript (extend/define)
14  * E) It does not modify any buildin prototypes.. 
15  *
16  * Extend this.. to use it's wonderful features..
17  * 
18  * normal usage:
19  * XObject = imports.XObject.XObject;
20  * 
21  * Xyz = new XObject({
22  *     xtype: Gtk.Window,
23  *     id : 'window',
24  *     items : [
25  *     
26  *     ]
27  *  });
28  *  Xyz.init(); // create and show.
29  * 
30  * 
31  * use XObject.debug = 1 to turn on debugging
32  * 
33  * If XObjectBase/[xns]/[xtype].js exists, it will use this to override properties..
34  * 
35  * 
36  * He's some questions.
37  * - should we have a special property to use as the constructor / gobject.properties rather
38  *   than sending all basic types to this?
39  * 
40  * @cfg xtype {String|Function} constructor or string.
41  * @cfg id {String}  (optional) id for registry
42  * @cfg xns {String|Object}   (optional) namespace eg. Gtk or 'Gtk' - used with xtype.
43  * @cfg items {Array}   (optional) list of child elements which will be constructed.. using XObject
44  * @cfg listeners {Object}   (optional) map Gobject signals to functions
45  * @cfg pack {Function|String|Array}   (optional) how this object gets added to it's parent
46  * @cfg el {Object}   (optional) premade GObject
47  *  
48  */
49
50 function XObject (cfg) {
51     // first apply cfg if set.
52       //print("new XOBJECT!!!");
53       
54     //print ("XObject ctr");
55       
56     this.config = {}; // used to initialize GObject
57     
58     this.cfg = XObject.extend({}, cfg); // used to store original configuration.. for referencing..
59     
60     // used by baseobject to create fake child elements on init..
61     if (cfg.el) {
62         this.el = cfg.el;
63     }
64     
65     // we could use this to determine if 
66     // we are actually inside a inherited class...
67     // as define() should actually set this up..
68     
69     if (!this.constructor) {
70         
71         this.constructor = XObject;
72         var base = XObject.baseXObject(cfg);
73         if (base) {
74             XObject.extend(this,  base.prototype);
75         }
76         
77     }
78     
79     // copy down all elements into self..
80     // make an extra copy in this.config?? - which is the one used in the constructor later
81     
82     for (var i in cfg) {
83         this[i] = cfg[i];
84         if (typeof(cfg[i]) == 'function') { // do we skip objects.
85             continue;
86         }
87         // these properties are not copied to cfg.
88         if (    i == 'pack' ||
89                 i == 'items' ||
90                 i == 'id' ||
91                 i == 'xtype' ||
92                 i == 'xdebug' ||
93                 i == 'xns') {
94             continue;
95         }
96         
97         
98         this.config[i] = cfg[i];
99     }
100     
101     
102     this.items = this.items || [];
103     
104     
105     // pack can be false!
106     if (typeof(this.pack) == 'undefined') {
107         
108         this.pack = [ 'add' ]
109         /*
110         var Gtk  = imports.gi.Gtk;
111         switch (true) {
112             // any others!!
113             case (this.xtype == Gtk.MenuItem):  this.pack = [ 'append' ]; break;
114             
115         }
116         */
117         
118     }
119     
120     // interesting question should we call constructor on items here...
121     // as the real work is done in init anyway..
122     var _this= this;
123  
124     var items = []
125     for(var i = 0; i < this.items.length;i++) {
126         items.push(this.items[i]);
127     }
128
129
130
131     this.items = [];
132     // create XObject for all the children.
133     for(var i = 0; i < items.length;i++) {
134     
135         var base = XObject.baseXObject(items[i]);
136         base = base || XObject;
137         var item = (items[i].constructor == XObject) ? items[i] : new base(items[i]);
138         item.parent = _this;
139         _this.items.push(item);
140         //_this.addItem(i);
141     };
142      
143     
144 }
145
146
147
148 XObject.prototype = {
149     /**
150      * @property el {GObject} the Gtk / etc. element.
151      */
152     el : false, 
153     /*
154      * @property items {Array} list of sub elements
155      */
156     /**
157      * @property parent {XObject} parent Element
158      */
159      
160      /**
161      * @property config {Object} the construction configuration.
162      */
163      /**
164       * @method init
165       * Initializes the Element (el) hooks up all the listeners
166       * and packs the children.
167       * you can override this, in child objects, then 
168       * do this to do thi initaliztion.
169       * 
170       * XObject.prototype.init.call(this); 
171       * 
172       */ 
173     init : function(parent)
174     {
175          
176        // var items = [];
177         //this.items.forEach(function(i) {
178         //    items.push(i);
179         //});
180         // remove items.
181         this.listeners = this.listeners || {}; 
182         //this.items = [];
183          
184         // do we need to call 'beforeInit here?'
185          
186         // handle include?
187         //if ((this.xtype == 'Include')) {
188         //    o = this.pre_registry[cls];
189         //}
190         var isSeed = typeof(Seed) != 'undefined';
191          
192         // xtype= Gtk.Menu ?? what about c_new stuff?
193         XObject.log("init: ID:"+ this.id +" typeof(xtype): "  + typeof(this.xtype));
194         if (!this.el && typeof(this.xtype) == 'function') {
195             XObject.log("func?"  + XObject.keys(this.config).join(','));
196             this.el = this.xtype(this.config);
197            
198         }
199         if (!this.el && typeof(this.xtype) == 'object') {
200             XObject.log("obj?"  + XObject.keys(this.config).join(','));
201             this.el = new (this.xtype)(this.config);
202       
203         }
204         //print(this.el);
205         if (!this.el && this.xns) {
206             
207             var NS = imports.gi[this.xns];
208             if (!NS) {
209                 XObject.error('Invalid xns: ' + this.xns, true);
210             }
211             constructor = NS[this.xtype];
212             if (!constructor) {
213                 XObject.error('Invalid xtype: ' + this.xns + '.' + this.xtype);
214             }
215             this.el  =   isSeed ? new constructor(this.config) : new constructor();
216             
217         }
218         XObject.log("init: ID:"+ this.id +" typeof(el):" + this.el);
219         
220         // always overlay props..
221         // check for 'write' on object..
222         /*
223         if (typeof(XObject.writeablePropsCache[this.xtype.type]) == 'undefined') {
224                 
225             var gi = GIRepository.IRepository.get_default();
226             var ty = gi.find_by_gtype(this.xtype.type);
227             var write = [];
228             for (var i =0; i < GIRepository.object_info_get_n_properties(ty);i++) {
229                 var p =   GIRepository.object_info_get_property(ty,i);
230                 if (GIRepository.property_info_get_flags(p) & 2) {
231                     write.push(GIRepository.base_info_get_name(p));
232                 }
233             }
234             XObject.writeablePropsCache[this.xtype.type] = write;
235             print(write.join(", "));
236         }
237         
238         */
239         
240          
241         for (var i in this.config) {
242             if (i == 'type') { // problem with Gtk.Window... - not decided on a better way to handle this.
243                 continue;
244             }
245             if (i == 'buttons') { // problem with Gtk.MessageDialog..
246                 continue;
247             }
248             if (i[0] == '.') { // parent? - 
249                 continue;
250             }
251             this.el[i] = this.config[i];
252         }
253         
254         // register it!
255         //if (o.xnsid  && o.id) {
256          //   XObject.registry = XObject.registry || { };
257          //   XObject.registry[o.xnsid] = XObject.registry[o.xnsid] || {}; 
258          //   XObject.registry[o.xnsid][o.id] = this;
259         //}
260         
261         var type = this.xtype.type ? GObject.type_name(this.xtype.type) : '';
262         XObject.log("add children to " + type);
263         
264         var _this=this;
265         for (var i = 0; i < this.items.length;i++) { 
266             _this.addItem(this.items[i],i);
267         }
268             
269         
270         for (var i in this.listeners) {
271             this.addListener(i, this.listeners[i]);
272         }
273         
274         this.init = XObject.emptyFn;
275            
276         // delete this.listeners ?
277         // do again so child props work!
278        
279         // do we need to call 'init here?'
280     },
281       
282      
283      /**
284       * Adds an item to the object using a new XObject
285       * uses pack property to determine how to add it.
286       * @arg cfg {Object} same as XObject constructor.
287       */
288     addItem : function(item, pos) 
289     {
290         
291         if (typeof(item) == 'undefined') {
292             XObject.error("Invalid Item added to this!");
293             imports.console.dump(this.cfg);
294             Seed.quit();
295         }
296         // what about extended items!?!?!?
297        
298         item.init(this);
299         //print("CTR:PROTO:" + ( item.id ? item.id : '??'));
300        // print("addItem - call init [" + item.pack.join(',') + ']');
301         if (!item.el) {
302             XObject.error("NO EL!");
303             imports.console.dump(item);
304             Seed.quit();
305         }
306         XObject.log(XObject.type(this.xtype) + ":pack=" + item.pack);
307         
308         if (item.pack===false) {  // no packing.. various items have this ..
309             return;
310         }
311         
312         if (typeof(item.pack) == 'function') { // pack is a function..
313             // parent, child
314             item.pack.apply(item, [ this , item  ]);
315             item.parent = this;
316             return;
317         }
318         
319         // pack =  'add,x,y'
320         var args = [];
321         var pack_m  = false;
322         if (typeof(item.pack) == 'string') {
323              
324             item.pack.split(',').forEach(function(e, i) {
325                 
326                 if (e == 'false') { args.push( false); return; }
327                 if (e == 'true') {  args.push( true);  return; }
328                 if (!isNaN(parseInt(e))) { args.push( parseInt(e)); return; }
329                 args.push(e);
330             });
331             //print(args.join(","));
332             
333             pack_m = args.shift();
334         } else {
335             pack_m = item.pack.shift();
336             args = item.pack;
337         }
338         
339         // handle error.
340         if (pack_m && typeof(this.el[pack_m]) == 'undefined') {
341             
342             throw {
343                 name: "ArgumentError", 
344                 message : 'pack method not available : ' + this.id + " : " + this.xtype + '.' +  pack_m + " ADDING " + item.el
345                     
346             }
347            
348             return;
349         }
350         
351         
352         // finally call the pack method 
353         //Seed.print('Pack ' + this.el + '.'+ pack_m + '(' + item.el + ')');
354         
355         args.unshift(item.el);
356         
357          
358         
359         
360         
361         XObject.log(pack_m + '[' + args.join(',') +']');
362         //Seed.print('args: ' + args.length);
363         if (pack_m) {
364             this.el[pack_m].apply(this.el, args);
365         }
366         
367        
368         
369     },
370     /**
371     * Connects a method to a signal. (gjs/Seed aware)
372     * 
373     * @param {String} sig  name of signal
374     * @param {Function} fn  handler.
375     */
376     addListener  : function(sig, fn) 
377     {
378  
379         XObject.log("Add signal " + sig);
380         fn.id= sig;
381         var _li = XObject.createDelegate(fn,this);
382         // private listeners that are not copied to GTk.
383         
384         if (typeof(Seed) != 'undefined') {
385           //   Seed.print(typeof(_li));
386             this.el.signal[sig].connect(_li);
387         } else {
388             this.el.connect( sig, _li);
389         }
390              
391         
392     },
393      /**
394       * @method get
395       * Finds an object in the child elements using xid of object.
396       * prefix with '.' to look up the tree.. 
397       * prefix with multiple '..' to look further up..
398       * prefix with '/' to look from the top, eg. '^LeftTree.model'
399       * 
400       * @param {String} name name of signal
401       * @return  {XObject|false} the object if found.
402       */
403     get : function(xid)
404     {
405         XObject.log("SEARCH FOR " + xid + " in " + this.id);
406         var ret=  false;
407         var oid = '' + xid;
408         if (!xid.length) {
409             throw {
410                 name: "ArgumentError", 
411                 message : "ID not found : empty id"
412             }
413         }
414         
415         if (xid[0] == '.') {
416             return this.parent.get(xid.substring(1));
417         }
418         if (xid[0] == '/') {
419             
420             if (typeof(XObject.cache[xid]) != 'undefined') {
421                 return XObject.cache[xid]; 
422             }
423             if (xid.indexOf('.') > -1) {
424                 
425                 var child = xid.split('.');
426                 var nxid = child.shift();
427                     
428                 child = child.join('.');
429                 if (typeof(XObject.cache[nxid]) != 'undefined') {
430                     return XObject.cache[nxid].get(child);
431                 }
432                 
433                 
434             }
435             var e = this;
436             while (e.parent) {
437                 e = e.parent;
438             }
439             
440             try {
441                 ret = e.get(xid.substring(1));
442             } catch (ex) { }
443             
444             if (!ret) {
445                 throw {
446                     name: "ArgumentError", 
447                     message : "ID not found : " + oid
448                 }
449             }
450             XObject.cache[xid] = ret;
451             return XObject.cache[xid];
452         }
453         var child = false;
454         
455         if (xid.indexOf('.') > -1) {
456             child = xid.split('.');
457             xid = child.shift();
458             
459             child = child.join('.');
460             
461         }
462         if (xid == this.id) {
463             try {
464                 return child === false ? this : this.get(child);
465             } catch (ex) {
466                 throw {
467                     name: "ArgumentError", 
468                     message : "ID not found : " + oid
469                 }
470             }
471             
472         }
473         
474         
475         this.items.forEach(function(ch) {
476             if (ret) {
477                 return;
478             }
479             if (ch.id == xid) {
480                 ret = ch;
481             }
482         })
483         if (ret) {
484             try {
485                 return child === false ? ret : ret.get(child);
486             } catch (ex) {
487                 throw {
488                     name: "ArgumentError", 
489                     message : "ID not found : " + oid
490                 }
491             }
492             
493         }
494         // iterate children.
495         var _this = this;
496         this.items.forEach(function(ch) {
497             if (ret) {
498                 return;
499             }
500             if (!ch.get) {
501                 XObject.error("invalid item...");
502                 imports.console.dump(_this);
503                 Seed.quit();
504             }
505             try {
506                 ret = ch.get(xid);
507             } catch (ex) { }
508             
509             
510         });
511         if (!ret) {
512             throw {
513                 name: "ArgumentError", 
514                 message : "ID not found : " + oid
515             }
516         }
517         try {
518             return child === false ? ret : ret.get(child);
519         } catch (ex) {
520             throw {
521                 name: "ArgumentError", 
522                 message : "ID not found : " + oid
523             }
524         }
525     }
526       
527       
528
529          
530      
531 /**
532  * Copies all the properties of config to obj.
533  *
534  * Pretty much the same as JQuery/Prototype.. or Roo.apply
535  * @param {Object} obj The receiver of the properties
536  * @param {Object} config The source of the properties
537  * @param {Object} defaults A different object that will also be applied for default values
538  * @return {Object} returns obj
539  * @member XObject extend
540  */
541
542
543 XObject.extend = function(o, c, defaults){
544     if(defaults){
545         // no "this" reference for friendly out of scope calls
546         XObject.extend(o, defaults);
547     }
548     if(o && c && typeof c == 'object'){
549         for(var p in c){
550             o[p] = c[p];
551         }
552     }
553     return o;
554 };
555
556 XObject.extend(XObject,
557 {
558      
559     /**
560      * @property {Boolean} debug XObject  debugging.  - set to true to debug.
561      * 
562      */
563     debug : true,
564     /**
565      * @property {Object} cache - cache of object ids
566      * 
567      */
568     cache: { },
569     /**
570      * Empty function
571      * 
572      */
573     emptyFn : function () { },
574       
575       
576       
577     /**
578      * Debug Logging
579      * @param {String|Object} output String to print.
580      */
581     log : function(output)
582     {
583         if (!this.debug) {
584             return;
585         }
586         print("LOG:" + output);  
587     },
588      
589     /**
590      * Error Logging
591      * @param {String|Object} output String to print.
592      */
593     error : function(output)
594     {
595         print("ERROR: " + output);  
596     },
597     /**
598      * fatal error
599      * @param {String|Object} output String to print.
600      */
601     fatal : function(output)
602     {
603         
604         throw {
605                 name: "ArgumentError", 
606                 message : output
607                     
608             }
609     },
610    
611     /**
612      * Copies all the properties of config to obj, if the do not exist.
613      * @param {Object} obj The receiver of the properties
614      * @param {Object} config The source of the properties
615      * @return {Object} returns obj
616      * @member Object extendIf
617      */
618
619
620     extendIf : function(o, c)
621     {
622
623         if(!o || !c || typeof c != 'object'){
624             return o;
625         }
626         for(var p in c){
627             if (typeof(o[p]) != 'undefined') {
628                 continue;
629             }
630             o[p] = c[p];
631         }
632         return o;
633     },
634
635  
636
637     /**
638      * Extends one class with another class and optionally overrides members with the passed literal. This class
639      * also adds the function "override()" to the class that can be used to override
640      * members on an instance.
641      *
642      * usage:
643      * MyObject = Object.define(
644      *     function(...) {
645      *          ....
646      *     },
647      *     parentClass, // or Object
648      *     {
649      *        ... methods and properties.
650      *     }
651      * });
652      * @param {Function} constructor The class inheriting the functionality
653      * @param {Object} superclass The class being extended
654      * @param {Object} overrides (optional) A literal with members
655      * @return {Function} constructor (eg. class
656      * @method define
657      */
658     define : function()
659     {
660         // inline overrides
661         var io = function(o){
662             for(var m in o){
663                 this[m] = o[m];
664             }
665         };
666         return function(constructor, parentClass, overrides) {
667             if (typeof(parentClass) == 'undefined') {
668                 XObject.error("XObject.define: Missing parentClass: when applying: " );
669                 XObject.error(new String(constructor));
670                 Seed.quit(); 
671             }
672             if (typeof(parentClass.prototype) == 'undefined') {
673                 XObject.error("Missing protype: when applying: " );
674                 XObject.error(new String(constructor));
675                 XObject.error(new String(parentClass));
676                 Seed.quit(); 
677             }
678             var F = function(){};
679             var sbp;
680             var spp = parentClass.prototype;
681             
682             F.prototype = spp;
683             sbp = constructor.prototype = new F();
684             sbp.constructor=constructor;
685             constructor.superclass=spp;
686
687             // extends Object.
688             if(spp.constructor == Object.prototype.constructor){
689                 spp.constructor=parentClass;
690             }
691             
692             constructor.override = function(o){
693                 Object.extend(constructor.prototype, o);
694             };
695             sbp.override = io;
696             XObject.extend(constructor.prototype, overrides);
697             return constructor;
698         };
699     }(),
700
701          
702     /**
703      * returns a list of keys of the object.
704      * @param {Object} obj object to inspect
705      * @return {Array} returns list of kyes
706      * @member XObject keys
707      */
708     keys : function(o)
709     {
710         var ret = [];
711         for(var i in o) {
712             ret.push(i);
713         }
714         return ret;
715     },
716     /**
717      * return the Gobject name of a constructor - does not appear to work on structs..
718      * @param {Object} gobject ctr
719      * @return {String} returns name
720      * @member XObject type
721      */
722     type : function(o)
723     {
724         if (typeof(o) == 'object') {
725             return GObject.type_name(o.type);
726            // print("GNAME:" +gname + " GTYPE:"+cfg.xtype.type);
727         }
728         return 'unknown';
729     },
730     /**
731      * return the XObjectBase class for a cfg (which includes an xtype)
732      * @param {Object} configuration.
733      * @return {function} constructor
734      * @member XObject baseXObject
735      */
736     baseXObject : function(cfg)
737     {
738           try {
739             // loocks for XObject/Gtk/TreeView.js [   TreeView = { .... } ]
740             // xns is not a string!!!?
741             var gname = false;
742             if (typeof(cfg.xtype) == 'object') {
743                 gname = XObject.type(cfg.xtype);
744             
745             }
746             if (typeof(cfg.xtype) == 'string') {
747                 gname  = cfg.xtype;
748             }
749             
750             XObject.log("TRYING BASE OBJECT : " + gname);
751             // in the situation where we have been called and there is a base object
752             // defining the behavior..
753             // then we should copy the prototypes from the base object into this..
754             
755             // see if file exists???
756             
757             var base = gname  ? imports.XObjectBase[gname][gname] : false;
758             return base;
759             
760         } catch (e) {
761             // if debug?
762             XObject.log("error finding " + gname + " - " + e.toString());
763             return false;
764         }
765         
766         
767     },
768     
769     /**
770      * @member XObject createDelegate
771      * creates a delage metdhod
772      * @param {Function} method to wrap
773      * @param {Object} scope 
774      * @param {Array} args to add
775      * @param {Boolean|Number} append arguments or replace after N arguments.
776      * @return {Function} returns the delegate
777      */
778
779     createDelegate : function(method, obj, args, appendArgs){
780         
781         return function() {
782             XObject.log("CALL: " + obj.id + ':'+ method.id);
783             
784             var callArgs = args || arguments;
785             if(appendArgs === true){
786                 callArgs = Array.prototype.slice.call(arguments, 0);
787                 callArgs = callArgs.concat(args);
788             }else if(typeof appendArgs == "number"){
789                 callArgs = Array.prototype.slice.call(arguments, 0); // copy arguments first
790                     var applyArgs = [appendArgs, 0].concat(args); // create method call params
791                     Array.prototype.splice.apply(callArgs, applyArgs); // splice them in
792                 }
793                 return method.apply(obj || window, callArgs);
794             };
795     }
796     
797 });