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
  75         methods[cls] = {
  76             can_contain : [],
  77             can_be_added_to : [],
  78             using_methods : { }
  79
  80         };
  81         var odata = classes[cls];
  82
  83         implementations[odata.alias] = odata.titleType == 'Class' ? odata.childClasses :  odata.implementedBy;
  84
  85     }
  86     for (cls in classes) {
  87         var odata = classes[cls];
  88
  89
  90         //print(JSON.stringify(odata.methods,null,4));
  91         odata.methods.forEach(function(m) {
  92
  93             m.params.forEach(function(p) {
  94
  95                 if (!p.type || typeof(classes[p.type]) == 'undefined') {
  96                     return;
  97                 }
  98                 // now add it..
  99                 //print(JSON.stringify(p));Seed.exit();
 100                 var addable_type = p.type;
 101                 if (addable_type.indexOf('.') < 0) {
 102                     addable_type = p.memberOf + '.' + p.type;
 103                 }
 104
 105
 106                 if (!m.name.match(/^(add|pack)/)) {
 107                     return;
 108                 }
 109
 110                 //print(full_method_name );
 111
 112                 //if (allmethods.indexOf(full_method_name) < 0) {
 113                 //    allmethods.push(full_method_name);
 114                 //}
 115                 if (methods[cls].can_contain.indexOf(addable_type) < 0) {
 116                     methods[cls].can_contain.push(addable_type);
 117                 }
 118                 methods[cls].using_methods[m.name] = m.params;
 119
 120                 return;
 121             /*
 122                     methods[cls].using_methods[m.name] = {};
 123                 }
 124
 125
 126                 if (typeof(methods[cls][full_method_name]) == 'undefined') {
 127                     methods[cls][full_method_name] = [];
 128                 }
 129                 if (methods[cls][full_method_name].indexOf(m.name) > -1) {
 130                     return;
 131                 }
 132                 methods[cls][full_method_name].push(m.name);
 133             */
 134             });
 135
 136         });
 137         //for(method in odata.methods) {
 138         //    print(method.name);
 139         //}
 140
 141
 142     }
 143     for (var p in methods) {
 144         for
 145
 146
 147
 148     }
 149
 150     // now do the reverese 'can be added to'
 151
 152
 153
 154     this.methods = methods;
 155     this.allmethods = methods;
 156     this.implementations = implementations;
 157     print(JSON.stringify(methods,null,4));
 158
 159     //print(JSON.stringify(implementations ,null,4));
 160     /*
 161       methods is
 162         [a class]
 163             [has methods that use this object]
 164                 [list of methods of the top class..]
 165
 166
 167       So let's pick one..
 168         TOP        ARRAY  2ND
 169         Gtk.Button.add(Gtk.Widget) <<
 170
 171
 172         What we need:
 173
 174         A) what can this dragged element be dropped onto.
 175         eg. list of parents.
 176
 177
 178
 179
 180         B) what method is available when this object is dropped onto this one.
 181
 182
 183
 184
 185
 186     */
 187
 188
 189     //print(JSON.stringify(implementations,null,4));
 190
 191 }
 192 BuildLists();
 193
 194 // we now have a list of classes / methods that can be used..
 195 // we now need a ui to flag stuff as "don't bother with"
 196
 197