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
 151
 152     // now do the reverese 'can be added to'
 153
 154
 155
 156     this.methods = methods;
 157     this.allmethods = methods;
 158     this.implementations = implementations;
 159     print(JSON.stringify(methods,null,4));
 160
 161     //print(JSON.stringify(implementations ,null,4));
 162     /*
 163       methods is
 164         [a class]
 165             [has methods that use this object]
 166                 [list of methods of the top class..]
 167
 168
 169       So let's pick one..
 170         TOP        ARRAY  2ND
 171         Gtk.Button.add(Gtk.Widget) <<
 172
 173
 174         What we need:
 175
 176         A) what can this dragged element be dropped onto.
 177         eg. list of parents.
 178
 179
 180
 181
 182         B) what method is available when this object is dropped onto this one.
 183
 184
 185
 186
 187
 188     */
 189
 190
 191     //print(JSON.stringify(implementations,null,4));
 192
 193 }
 194 BuildLists();
 195
 196 // we now have a list of classes / methods that can be used..
 197 // we now need a ui to flag stuff as "don't bother with"
 198
 199