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                 if (methods[addable_type].can_be_added_to.indexOf(cls) < 0) {
 121                     methods[addable_type].can_be_added_to.push(cls);
 122                 }
 123
 124
 125
 126
 127                 return;
 128             /*
 129                     methods[cls].using_methods[m.name] = {};
 130                 }
 131
 132
 133                 if (typeof(methods[cls][full_method_name]) == 'undefined') {
 134                     methods[cls][full_method_name] = [];
 135                 }
 136                 if (methods[cls][full_method_name].indexOf(m.name) > -1) {
 137                     return;
 138                 }
 139                 methods[cls][full_method_name].push(m.name);
 140             */
 141             });
 142
 143         });
 144         //for(method in odata.methods) {
 145         //    print(method.name);
 146         //}
 147
 148
 149     }
 150     for (var p in methods) {
 151         for
 152
 153
 154
 155     }
 156
 157     // now do the reverese 'can be added to'
 158
 159
 160
 161     this.methods = methods;
 162     this.allmethods = methods;
 163     this.implementations = implementations;
 164     print(JSON.stringify(methods,null,4));
 165
 166     //print(JSON.stringify(implementations ,null,4));
 167     /*
 168       methods is
 169         [a class]
 170             [has methods that use this object]
 171                 [list of methods of the top class..]
 172
 173
 174       So let's pick one..
 175         TOP        ARRAY  2ND
 176         Gtk.Button.add(Gtk.Widget) <<
 177
 178
 179         What we need:
 180
 181         A) what can this dragged element be dropped onto.
 182         eg. list of parents.
 183
 184
 185
 186
 187         B) what method is available when this object is dropped onto this one.
 188
 189
 190
 191
 192
 193     */
 194
 195
 196     //print(JSON.stringify(implementations,null,4));
 197
 198 }
 199 BuildLists();
 200
 201 // we now have a list of classes / methods that can be used..
 202 // we now need a ui to flag stuff as "don't bother with"
 203
 204