X-Git-Url: http://git.roojs.org/?a=blobdiff_plain;f=tools%2Fbuild_gtk_tree.js;h=7b8c579e6e64e01be409e763fa370959ecc70ecb;hb=15ea2c35066db7f6a5fd74a701963a07280e6c24;hp=c490a0a65812c042badce46869860533e7fbb5ac;hpb=167b9f3afd84986d5e960f5850d82eec21006b56;p=app.Builder.js diff --git a/tools/build_gtk_tree.js b/tools/build_gtk_tree.js index c490a0a65..7b8c579e6 100644 --- a/tools/build_gtk_tree.js +++ b/tools/build_gtk_tree.js @@ -37,11 +37,18 @@ NameSpace = imports.Introspect.NameSpace.NameSpace; Link = imports.Introspect.Link.Link; +Array.prototype.pushUnique = function(v) { + if (this.indexOf(v) < 0) { + this.push(v); + } +} function BuildLists () { + + - var ns_list = [ 'Gtk' ] ; //NameSpace.namespaces(); + var ns_list = [ 'Gtk' , 'Gdk', 'Pango', 'GtkSource', 'WebKit', 'Vte'] ; //NameSpace.namespaces(); ns_list = ns_list.sort(); // let's try and load them, so we find out early what will fail. @@ -62,35 +69,154 @@ function BuildLists () { classes[odata.alias] = odata; }); }); - + //print(JSON.stringify(classes['Gtk.CellRenderer'] , null, 4)); + //print(JSON.stringify(classes['Gtk.CellRenderer'].titleType, null, 4)); + //print(JSON.stringify(classes['Gtk.CellRenderer'].childClasses, null, 4)); + //print(JSON.stringify(classes['Gtk.CellRenderer'].implementedBy, null, 4)); + + print("Looping throught namespaces"); var ns_idx = []; var implementations = {}; + var methods = {}; var allmethods = []; for (cls in classes) { var odata = classes[cls]; - methods[cls] = {} - - implementations[odata.alias] = odata.titleType == 'Class' ? odata.childClasses : odata.implementedBy; + + methods[cls] = { + //titleType : odata.titleType, + extendsClasses : [], + can_contain : [], + // can_be_added_to : [], + //using_methods : { }, + can_be_added_to_as : {} + }; + odata.extendsClasses.forEach(function(child) { + methods[cls].extendsClasses.push(child.alias); + }); + + implementations[odata.alias] = odata.titleType == 'Class' ? odata.childClasses : odata.implementedBy; + + } + for (cls in classes) { + var odata = classes[cls]; + + + + //print(cls); //print(JSON.stringify(odata.methods,null,4)); odata.methods.forEach(function(m) { - + + + + + if (!m.name.match(/^(add|pack)/)) { + return; + } + //print(JSON.stringify(m,null,4)); m.params.forEach(function(p) { if (!p.type || typeof(classes[p.type]) == 'undefined') { return; } // now add it.. + //print(JSON.stringify(p));Seed.exit(); + var addable_type = p.type; + if (addable_type.indexOf('.') < 0) { + addable_type = p.memberOf + '.' + p.type; + } - var full_method_name = p.memberOf + '.' + p.type; - print(full_method_name ); - if (allmethods.indexOf(full_method_name) < 0) { - allmethods.push(full_method_name); + + // in theory you can not add a window to anything.. ??? + //if ('Gtk.Window' == addable_type || methods[addable_type].extendsClasses.indexOf('Gtk.Window') > -1) { + // return; + //} + // + + //print(full_method_name ); + + //if (allmethods.indexOf(full_method_name) < 0) { + // allmethods.push(full_method_name); + //} + + methods[cls].can_contain.pushUnique(addable_type); + + //methods[cls].using_methods[m.name] = m.params; + + //if (methods[addable_type].can_be_added_to.indexOf(cls) < 0) { + // methods[addable_type].can_be_added_to.push(cls); + //} + + + var add = m.memberOf +':'+ m.name; + + if (typeof(methods[addable_type].can_be_added_to_as[cls]) == 'undefined') { + methods[addable_type].can_be_added_to_as[cls]=[]; } + methods[addable_type].can_be_added_to_as[cls].pushUnique( add ); + implementations[cls].forEach(function(imp) { + + + if (typeof(methods[addable_type ].can_be_added_to_as[imp]) == 'undefined') { + methods[addable_type].can_be_added_to_as[imp] = []; + } + + methods[addable_type].can_be_added_to_as[imp].pushUnique(add); + + + }); + // also needs to add + //print(addable_type); + //print(JSON.stringify(implementations[addable_type], null,4)); + + + implementations[addable_type].forEach(function(addable_child) { + + //if (addable_child == 'Gtk.AboutDialog') { + // print(JSON.stringify(methods[addable_child].extendsClasses,null,4));Seed.exit(); + + //} + + if (addable_child == 'Gtk.Window' || + methods[addable_child].extendsClasses.indexOf('Gtk.Window') > -1) { + return; + } + + if (typeof(methods[addable_child].can_be_added_to_as[cls]) == 'undefined') { + methods[addable_child].can_be_added_to_as[cls]=[]; + } + methods[addable_child].can_be_added_to_as[cls].pushUnique( add ); + implementations[cls].forEach(function(imp) { + if (typeof(methods[addable_child ].can_be_added_to_as[imp]) == 'undefined') { + methods[addable_child].can_be_added_to_as[imp] = []; + } + + methods[addable_child].can_be_added_to_as[imp].pushUnique(add); + + + }); + + + + }); + + + + + + + + + + return; + /* + methods[cls].using_methods[m.name] = {}; + } + if (typeof(methods[cls][full_method_name]) == 'undefined') { methods[cls][full_method_name] = []; @@ -99,7 +225,7 @@ function BuildLists () { return; } methods[cls][full_method_name].push(m.name); - + */ }); }); @@ -109,10 +235,138 @@ function BuildLists () { } + /* + // fill in the added to list.. + for(var p in methods ) { + var odata = methods[p]; + + methods[p].can_be_added_to.forEach(function(c) { + methods[p].can_be_added_to_as[c]=c; + implementations[c].forEach(function(imp) { + methods[p].can_be_added_to_as[imp]=c; + }); + }); + + + } + */ + // now do the reverese 'can be added to' + + + this.methods = methods; this.allmethods = methods; this.implementations = implementations; - print(JSON.stringify(methods,null,4)); + //print(JSON.stringify(methods,null,4)); + // dump out a usage file.. + + // basically anything that is a Gtk.Container, should be available at the top. + /* +left: + *top +right: + Gtk.Window + Gtk.Dialog + Gtk.MessageDialog + Gtk.AboutDialog + Gtk.Dialog + Gtk.FontSelectionDialog + Gtk.InputDialog + Gtk.ColorSelectionDialog + Gtk.FileChooserDialog + Gtk.Menu + GtkClutter.Window + Gtk.OffScreenWindow + */ +// these should really be based on heirachy.. + usage = {}; + tops = {} + usage['*top'] = implementations['Gtk.Container']; + usage['*top'].forEach(function(ch) { + tops[ch] = [ '*top' ]; + }); + for(var cls in methods) { + for (var par in methods[cls].can_be_added_to_as) { + if (typeof(usage[par]) == 'undefined') { + usage[par] = []; + } + usage[par].pushUnique(cls); + if (typeof(tops[cls]) == 'undefined') { + tops[cls] = []; + } + tops[cls].pushUnique(par); + } + } + function canTop(cls, rec) { + + rec = rec || 0; + print('CANTOP: ' + cls + ' =' + rec); + if (rec > 5) { + print('SKIP : ' + cls); + } + if (typeof(tops[cls]) == 'undefined') { + return false; + } + for (var i =0; i < tops[cls].length; i++) { + if (tops[cls][i] == '*top') { + return true; + } + if (cls == tops[cls][i]) { + continue; + } + if (canTop(tops[cls][i], rec+1)) { + return true; + } + } + return false; + + } + var nusage = {}; + for(var par in usage) { + // see if the parent can be added to something. + if (!canTop(par)) { + continue; + } + nusage[par] = usage[par]; + + } + + print(JSON.stringify(nusage,null,4)); + + + + + //print(JSON.stringify(implementations ,null,4)); + /* + methods is + [a class] + [has methods that use this object] + [list of methods of the top class..] + + + So let's pick one.. + TOP ARRAY 2ND + Gtk.Button.add(Gtk.Widget) << + + + What we need: + + A) what can this dragged element be dropped onto. + eg. list of parents. + - can_be_added_to_as (left) + + + + B) what method is available when this object is dropped onto this one. + + - get the right hand side? + + + + + */ + + //print(JSON.stringify(implementations,null,4)); }