git.roojs.org Git - app.Builder.js/blob - tools/build_gtk_tree.js

   1 //<script type="text/javascript">
   2
   3
   4 /**
   5  * usage:
   6  *
   7  * this.data = new BuildLists();
   8  *
   9  *
  10  *
  11  *
  12  *
  13  */
  14 // see if we can build the insertion tree for gtk - using introspection
  15
  16 // it should build the tree of feasible insertions, then we will have to manually prune it..
  17
  18 // it needs to know
  19 // a) what the inherited types are
  20 // b) what methods are available for each type, that include a reference to another type..
  21
  22 // let's start with types..
  23 GIRepository = imports.gi.GIRepository;
  24 GLib        = imports.gi.GLib;
  25
  26 // we add this in, as it appears to get lost sometimes if we set it using the ENV. variable in builder.sh
  27 //GIRepository.Repository.prepend_search_path(GLib.get_home_dir() + '/.Builder/girepository-1.1');
  28
  29
  30 imports.searchPath.push('../../gnome.introspection-doc-generator');
  31
  32 XObject     = imports.XObject.XObject;
  33 File        = imports.File.File;
  34
  35 // Introspecion specific..
  36 NameSpace   = imports.Introspect.NameSpace.NameSpace;
  37 Link        = imports.Introspect.Link.Link;
  38
  39
  40
  41 function BuildLists () {
  42
  43
  44     var ns_list = [ 'Gtk' ] ; //NameSpace.namespaces();
  45
  46     ns_list = ns_list.sort();
  47     // let's try and load them, so we find out early what will fail.
  48     print("loading library to make sure it works.");
  49
  50     var classes = {};
  51
  52     ns_list.forEach(function(ns_name) {
  53         var  core = imports.gi[ns_name];
  54         var ns = NameSpace.ns(ns_name); // fetch all the elements in namespace...
  55         ns['objects'].forEach( function(n) {
  56             var odata = NameSpace.factory('Class', ns_name, n);
  57             classes[odata.alias] = odata;
  58
  59         });
  60         ns['interfaces'].forEach( function(n) {
  61              var odata =NameSpace.factory('Interface', ns_name, n);
  62             classes[odata.alias] = odata;
  63         });
  64     });
  65
  66
  67     print("Looping throught namespaces");
  68     var ns_idx = [];
  69     var implementations = {};
  70     var methods = {};
  71     var allmethods = [];
  72
  73     for (cls in classes) {
  74         var odata = classes[cls];
  75         methods[cls] = {
  76             can_contain : [],
  77             can_be_added_to : [],
  78             using_methods : { }.
  79
  80         };
  81
  82         implementations[odata.alias] = odata.titleType == 'Class' ? odata.childClasses :  odata.implementedBy;
  83         //print(JSON.stringify(odata.methods,null,4));
  84         odata.methods.forEach(function(m) {
  85
  86             m.params.forEach(function(p) {
  87
  88                 if (!p.type || typeof(classes[p.type]) == 'undefined') {
  89                     return;
  90                 }
  91                 // now add it..
  92                 //print(JSON.stringify(p));Seed.exit();
  93                 var addable_type = p.type;
  94                 if (addable_type.indexOf('.') < 0) {
  95                     addable_type = p.memberOf + '.' + p.type;
  96                 }
  97
  98
  99                 if (!m.name.match(/^(add|pack)/)) {
 100                     return;
 101                 }
 102
 103                 //print(full_method_name );
 104
 105                 //if (allmethods.indexOf(full_method_name) < 0) {
 106                 //    allmethods.push(full_method_name);
 107                 //}
 108                 if (methods[cls].can_contain.indexOf(addable_type) < 0) {
 109                     methods[cls].can_contain.push(addable_type);
 110                 }
 111                 methods[cls].using_methods[m.name] = m.params;
 112
 113                 return;
 114             /*
 115                     methods[cls].using_methods[m.name] = {};
 116                 }
 117
 118
 119                 if (typeof(methods[cls][full_method_name]) == 'undefined') {
 120                     methods[cls][full_method_name] = [];
 121                 }
 122                 if (methods[cls][full_method_name].indexOf(m.name) > -1) {
 123                     return;
 124                 }
 125                 methods[cls][full_method_name].push(m.name);
 126             */
 127             });
 128
 129         });
 130         //for(method in odata.methods) {
 131         //    print(method.name);
 132         //}
 133
 134
 135     }
 136
 137
 138     // now do the reverese 'can be added to'
 139
 140
 141
 142     this.methods = methods;
 143     this.allmethods = methods;
 144     this.implementations = implementations;
 145     print(JSON.stringify(methods,null,4));
 146
 147     //print(JSON.stringify(implementations ,null,4));
 148     /*
 149       methods is
 150         [a class]
 151             [has methods that use this object]
 152                 [list of methods of the top class..]
 153
 154
 155       So let's pick one..
 156         TOP        ARRAY  2ND
 157         Gtk.Button.add(Gtk.Widget) <<
 158
 159
 160         What we need:
 161
 162         A) what can this dragged element be dropped onto.
 163         eg. list of parents.
 164
 165
 166
 167
 168         B) what method is available when this object is dropped onto this one.
 169
 170
 171
 172
 173
 174     */
 175
 176
 177     //print(JSON.stringify(implementations,null,4));
 178
 179 }
 180 BuildLists();
 181
 182 // we now have a list of classes / methods that can be used..
 183 // we now need a ui to flag stuff as "don't bother with"
 184
 185