--- /dev/null
+
+// valac -g --pkg gee-1.0 --pkg libxml-2.0 --pkg gobject-introspection-1.0 --pkg json-glib-1.0 Palete/Gir.vala -o /tmp/Gir
+/*
+public static int main (string[] args) {
+
+ var g = Palete.Gir.factory("Gtk");
+ var test = g.classes.get("ToolButton");
+
+
+ var generator = new Json.Generator ();
+ var n = new Json.Node(Json.NodeType.OBJECT);
+ n.set_object(test.toJSON());
+ generator.set_root(n);
+ generator.indent = 4;
+ generator.pretty = true;
+
+ print(generator.to_data(null));
+ return 0;
+}
+ */
+namespace Palete {
+ public errordomain GirError {
+ INVALID_TYPE,
+ NEED_IMPLEMENTING,
+ MISSING_FILE,
+ INVALID_VALUE,
+ INVALID_FORMAT
+ }
+ public class GirObject: Object {
+ public string name;
+ public string ns;
+ public string propertyof;
+ public string type;
+ public string nodetype;
+ public string package;
+
+ public GirObject paramset = null;
+ public GirObject return_value = null;
+
+ public bool is_instance;
+ public bool is_array;
+ public bool is_varargs;
+ public bool ctor_only; // specially added ctor properties..
+ public string parent;
+ public string value;
+ // to be filled in...
+
+ public string sig;
+
+ bool is_overlaid;
+
+ public GirObject gparent;
+ public Gee.ArrayList<GirObject> params;
+ public Gee.ArrayList<string> implements;
+ public Gee.ArrayList<string> inherits; // full list of all classes and interfaces...
+ public Gee.HashMap<string,GirObject> ctors;
+ public Gee.HashMap<string,GirObject> methods;
+ public Gee.HashMap<string,string> includes;
+ public Gee.HashMap<string,GirObject> classes;
+ public Gee.HashMap<string,GirObject> props;
+ public Gee.HashMap<string,GirObject> consts;
+ public Gee.HashMap<string,GirObject> signals;
+ public string doctxt;
+
+
+
+ public GirObject(string nodetype, string n)
+ {
+ this.nodetype = nodetype;
+ this.name = n;
+ this.ns = "";
+ this.parent = "";
+ this.type = "";
+ this.propertyof = "";
+ this.is_array = false;
+ this.is_instance = false;
+ this.is_varargs = false;
+ this.ctor_only =false;
+ this.doctxt = "";
+
+ this.sig = "";
+
+ this.gparent = null;
+
+ this.implements = new Gee.ArrayList<string>();
+ this.inherits = new Gee.ArrayList<string>(); // list of all ancestors. (interfaces and parents)
+ this.includes = new Gee.HashMap<string,string>();
+
+ this.params = new Gee.ArrayList<GirObject>();
+ this.ctors = new Gee.HashMap<string,GirObject>();
+ this.methods =new Gee.HashMap<string,GirObject>();
+
+ this.classes = new Gee.HashMap<string,GirObject>();
+ this.props = new Gee.HashMap<string,GirObject>();
+ this.consts = new Gee.HashMap<string,GirObject>();
+ this.signals = new Gee.HashMap<string,GirObject>();
+ this.is_overlaid = false;
+ this.paramset = null;
+ }
+
+ public string[] inheritsToStringArray()
+ {
+ string[] ret = {};
+ for(var i =0;i< this.inherits.size; i++) {
+ ret += this.inherits.get(i);
+ }
+ return ret;
+
+ }
+
+
+ public void overlayParent()
+ {
+
+ if (this.parent.length < 1 || this.is_overlaid) {
+ this.is_overlaid = true;
+ return;
+ }
+ // print("Overlaying " +this.name + " with " + this.parent + "\n");
+
+ var pcls = this.clsToObject( this.parent);
+ if (pcls == null) {
+ throw new GirError.INVALID_VALUE("Could not find class : " +
+ this.parent + " of " + this.name + " in " + this.ns);
+ }
+
+ pcls.overlayParent( );
+ this.copyFrom(pcls,false);
+ for(var i=0; i < this.implements.size; i++) {
+ var clsname = this.implements.get(i);
+ var picls = this.clsToObject(clsname);
+ this.copyFrom(picls,true);
+ }
+ this.is_overlaid = true;
+
+ }
+
+ public void overlayCtorProperties()
+ {
+ //print("Check overlay Ctor %s\n", this.name);
+ if (!this.ctors.has_key("new")) {
+ return;
+ }
+ var ctor = this.ctors.get("new");
+ if (ctor.paramset == null || ctor.paramset.params.size < 1) {
+ return;
+ }
+ //print("Found Ctor\n");
+ var iter = ctor.paramset.params.list_iterator();
+ while (iter.next()) {
+ var n = iter.get().name;
+
+ if (this.props.has_key(n)) {
+ continue;
+ }
+ if (n == "...") {
+ continue;
+ }
+ //print("Adding prop %s\n", n);
+
+ // it's a new prop..
+ var c = new GirObject("Prop",n);
+ c.gparent = this;
+ c.ns = this.ns;
+ c.propertyof = this.name;
+ c.type = iter.get().type;
+ c.ctor_only = true;
+ this.props.set(n, c);
+ }
+
+
+ }
+
+
+
+ public GirObject clsToObject(string in_pn)
+ {
+ var pn = in_pn;
+ var gir = Gir.factory (this.ns);
+ if (in_pn.contains(".")) {
+ gir = Gir.factory(in_pn.split(".")[0]);
+ pn = in_pn.split(".")[1];
+ }
+
+ return gir.classes.get(pn);
+
+
+ }
+ public string fqn() {
+ // not sure if fqn really is correct here...
+ //
+ return this.nodetype == "Class" || this.nodetype=="Interface"
+ ? this.name : (this.ns + this.name);
+ }
+
+ public void copyFrom(GirObject pcls, bool is_interface)
+ {
+
+ this.inherits.add(pcls.fqn());
+
+ var liter = pcls.inherits.list_iterator();
+ while(liter.next()) {
+ if (this.inherits.contains(liter.get())) {
+ continue;
+ }
+ this.inherits.add(liter.get());
+ }
+
+
+ var iter = pcls.methods.map_iterator();
+ while(iter.next()) {
+ if (null != this.methods.get(iter.get_key())) {
+ continue;
+ }
+
+ this.methods.set(iter.get_key(), iter.get_value());
+ }
+
+ iter = pcls.props.map_iterator();
+ while(iter.next()) {
+ if (null != this.props.get(iter.get_key())) {
+ continue;
+ }
+
+ this.props.set(iter.get_key(), iter.get_value());
+ }
+
+ iter = pcls.signals.map_iterator();
+ while(iter.next()) {
+ if (null != this.signals.get(iter.get_key())) {
+ continue;
+ }
+
+ this.signals.set(iter.get_key(), iter.get_value());
+ }
+ }
+
+ public Json.Object toJSON()
+ {
+ var r = new Json.Object();
+ r.set_string_member("nodetype", this.nodetype);
+ r.set_string_member("name", this.name);
+ if (this.propertyof.length > 0) {
+ r.set_string_member("of", this.propertyof);
+ }
+ if (this.type.length > 0) {
+ r.set_string_member("type", this.type);
+ }
+ if (this.parent != null && this.parent.length > 0) {
+ r.set_string_member("parent", this.parent);
+ }
+ if (this.sig.length > 0) {
+ r.set_string_member("sig", this.sig);
+ }
+
+ // is_arary / is_instance / is_varargs..
+
+
+ if (this.inherits.size > 0) {
+ r.set_array_member("inherits", this.toJSONArrayString(this.inherits));
+ }
+
+ if (this.implements.size > 0) {
+ r.set_array_member("implements", this.toJSONArrayString(this.implements));
+ }
+
+ if (this.params.size > 0) {
+ r.set_array_member("params", this.toJSONArrayObject(this.params));
+ }
+ if (this.ctors.size > 0) {
+ r.set_object_member("ctors", this.toJSONObject(this.ctors));
+ }
+ if (this.methods.size > 0) {
+ r.set_object_member("methods", this.toJSONObject(this.methods));
+ }
+ if (this.includes.size > 0) {
+ r.set_object_member("includes", this.toJSONObjectString(this.includes));
+ }
+ if (this.classes.size > 0) {
+ r.set_object_member("classes", this.toJSONObject(this.classes));
+ }
+ if (this.props.size > 0) {
+ r.set_object_member("props", this.toJSONObject(this.props));
+ }
+ if (this.consts.size > 0) {
+ r.set_object_member("consts", this.toJSONObject(this.consts));
+ }
+ if (this.signals.size > 0) {
+ r.set_object_member("signals", this.toJSONObject(this.signals));
+ }
+ if (this.paramset != null) {
+ r.set_object_member("paramset", this.paramset.toJSON());
+ }
+ if (this.return_value != null) {
+ r.set_object_member("return_value", this.return_value.toJSON());
+ }
+ return r;
+ }
+ public Json.Object toJSONObject(Gee.HashMap<string,GirObject> map)
+ {
+ var r = new Json.Object();
+ var iter = map.map_iterator();
+ while(iter.next()) {
+ r.set_object_member(iter.get_key(), iter.get_value().toJSON());
+ }
+ return r;
+ }
+ public Json.Object toJSONObjectString(Gee.HashMap<string,string> map)
+ {
+ var r = new Json.Object();
+ var iter = map.map_iterator();
+ while(iter.next()) {
+ r.set_string_member(iter.get_key(), iter.get_value());
+ }
+ return r;
+ }
+ public Json.Array toJSONArrayString(Gee.ArrayList<string> map)
+ {
+ var r = new Json.Array();
+ for(var i =0;i< map.size;i++) {
+
+ r.add_string_element(map.get(i));
+ }
+ return r;
+ }
+ public Json.Array toJSONArrayObject(Gee.ArrayList<GirObject> map)
+ {
+ var r = new Json.Array();
+ for(var i =0;i< map.size;i++) {
+
+ r.add_object_element(map.get(i).toJSON());
+ }
+ return r;
+ }
+ public string asJSONString()
+ {
+ var generator = new Json.Generator ();
+ generator.indent = 4;
+ generator.pretty = true;
+ var n = new Json.Node(Json.NodeType.OBJECT);
+ n.set_object(this.toJSON());
+ generator.set_root(n);
+
+ return generator.to_data(null);
+ }
+
+
+ public GirObject fetchByFqn(string fqn) {
+ //print("Searching (%s)%s for %s\n", this.nodetype, this.name, fqn);
+ var bits = fqn.split(".");
+
+ var ret = this.classes.get(bits[0]);
+ if (ret != null) {
+ if (bits.length < 2) {
+ return ret;
+ }
+ return ret.fetchByFqn(fqn.substring(bits[0].length+1));
+ }
+
+ ret = this.ctors.get(bits[0]);
+ if (ret != null) {
+ if (bits.length < 2) {
+ return ret;
+ }
+ return ret.fetchByFqn(fqn.substring(bits[0].length+1));
+ }
+
+ ret = this.methods.get(bits[0]);
+ if (ret != null) {
+ if (bits.length < 2) {
+ return ret;
+ }
+ return ret.fetchByFqn(fqn.substring(bits[0].length+1));
+ }
+ ret = this.props.get(bits[0]);
+ if (ret != null) {
+ if (bits.length < 2) {
+ return ret;
+ }
+ return ret.fetchByFqn(fqn.substring(bits[0].length+1));
+ }
+ ret = this.consts.get(bits[0]);
+ if (ret != null) {
+ if (bits.length < 2) {
+ return ret;
+ }
+ return ret.fetchByFqn(fqn.substring(bits[0].length+1));
+ }
+
+ ret = this.signals.get(bits[0]);
+ if (ret != null) {
+ if (bits.length < 2) {
+ return ret;
+ }
+ return ret.fetchByFqn(fqn.substring(bits[0].length+1));
+ }
+ if (this.paramset == null) {
+ return null;
+ }
+ var iter = this.paramset.params.list_iterator();
+ while (iter.next()) {
+ var p = iter.get();
+ if (p.name != bits[0]) {
+ continue;
+ }
+ return p;
+ }
+
+ // fixme - other queires? - enums?
+ return null;
+ }
+
+ public string fqtype() {
+ return Gir.fqtypeLookup(this.type, this.ns);
+ }
+ }
+
+
+
+
+
+ public class Gir : GirObject {
+
+ static Gee.HashMap<string,Gir> cache = null;
+ //Gee.Hashmap<string,what> nodes;
+
+
+
+ public static Gir? factory(string ns) {
+ if (cache == null) {
+ cache = new Gee.HashMap<string,Gir>();
+ }
+ var ret = cache.get(ns);
+ if (ret == null) {
+
+ var add = new Gir(ns);
+ cache.set(ns, add);
+
+ var iter = add.classes.map_iterator();
+ while(iter.next()) {
+ iter.get_value().overlayParent();
+ }
+ // loop again and add the ctor properties.
+ iter = add.classes.map_iterator();
+ while(iter.next()) {
+ iter.get_value().overlayCtorProperties();
+ }
+
+
+ ret = cache.get(ns);
+ }
+
+
+ return ret;
+
+ }
+ public static GirObject? factoryFqn(string fqn)
+ {
+ var bits = fqn.split(".");
+ if (bits.length < 1) {
+ return null;
+ }
+
+ var f = (GirObject)factory(bits[0]);
+
+ if (bits.length == 1 || f ==null) {
+ return f;
+ }
+ return f.fetchByFqn(fqn.substring(bits[0].length+1)); // since classes are stored in fqn format...?
+
+
+ }
+
+
+ /**
+ * guess the fqn of a type == eg. gboolean or Widget etc...
+ */
+ public static string fqtypeLookup(string type, string ns) {
+ var g = factory(ns);
+ if (g.classes.has_key(type)) {
+ return ns + "." + type;
+ }
+ // enums..
+ if (g.consts.has_key(type)) {
+ return ns + "." + type;
+ }
+
+
+ // look at includes..
+ var iter = g.includes.map_iterator();
+ while(iter.next()) {
+ // skip empty namespaces on include..?
+ if ( iter.get_key() == "") {
+ continue;
+ }
+ var ret = fqtypeLookup(type, iter.get_key());
+ if (ret != type) {
+ return ret;
+ }
+ }
+ return type;
+ }
+
+
+
+
+
+ public static string guessDefaultValueForType(string type) {
+ //print("guessDefaultValueForType: %s\n", type);
+ if (type.length < 1 || type.contains(".")) {
+ return "null";
+ }
+ switch(type) {
+ case "gboolean":
+ return "true";
+ case "guint":
+ return "0";
+ case "utf8":
+ return "\"\"";
+ default:
+ return "?"+ type + "?";
+ }
+
+ }
+
+
+
+
+ public Gir (string ns)
+ {
+ var xns = ns == "Glade" ? "Gladeui" : ns;
+ var gi = GI.Repository.get_default();
+ gi.require(xns, null, 0);
+
+ var ver = gi.get_version(xns);
+ unowned GLib.SList<string> pth = GI.Repository.get_search_path ();
+ var gir_path = pth.nth_data(0).replace("/lib/girepository-1.0", "/share/gir-1.0");
+ // 64bit...
+ gir_path = gir_path.replace("/lib/x86_64-linux-gnu/girepository-1.0", "/share/gir-1.0");
+
+ //console.log(fn);
+
+
+
+ var file = gir_path + "/" + xns + "-" + ver + ".gir";
+ // print("ns: " + ns + "\n");
+ // print("ver: " + ver + "\n");
+ // print(file);
+
+
+ base("Package",ns);
+ this.ns = ns;
+ //this.nodes = new Gee.Hashmap<string,what>();
+
+ var doc = Xml.Parser.parse_file (file);
+ var root = doc->get_root_element();
+ this.walk( root, (GirObject) this );
+
+ delete doc;
+
+ }
+ public void walk(Xml.Node* element, GirObject? parent)
+ {
+ var n = element->get_prop("name");
+ // ignore null or c:include...
+ if (n == null || (element->ns->prefix != null && element->ns->prefix == "c")) {
+ n = "";
+ }
+ //print("%s:%s (%s ==> %s\n", element->ns->prefix , element->name , parent.name , n);
+ switch (element->name) {
+ case "repository":
+ break;
+
+ case "include":
+ parent.includes.set(n, element->get_prop("version"));
+ break;
+
+ case "package":
+ parent.package = n;
+ break;
+
+ case "c:include":
+ break;
+
+ case "namespace":
+ parent.name = n;
+ break;
+
+ case "alias":
+ return;
+ //break; // not handled..
+
+ case "class":
+ var c = new GirObject("Class", parent.name + "." + n);
+ parent.classes.set(n, c);
+ c.ns = this.ns;
+ c.parent = element->get_prop("parent");
+ c.gparent = parent;
+ if (c.parent == null) {
+ c.parent = "";
+ }
+ parent = c;
+ break;
+
+ case "interface":
+ var c = new GirObject("Interface", parent.name + "." + n);
+ c.gparent = parent;
+ parent.classes.set(n, c);
+ c.ns = this.ns;
+ c.ns = parent.name;
+ c.parent = element->get_prop("parent");
+ if (c.parent == null) {
+ c.parent = "";
+ }
+ parent = c;
+ break;
+
+
+ case "doc":
+ parent.doctxt = element->get_content();
+ return;
+
+ case "implements":
+ parent.implements.add(n);
+
+ break;
+
+ case "constructor":
+ var c = new GirObject("Ctor",n);
+ c.ns = this.ns;
+ c.gparent = parent;
+ parent.ctors.set(n,c);
+ parent = c;
+ break;
+
+ case "return-value":
+ var c = new GirObject("Return", "return-value");
+ c.gparent = parent;
+ c.ns = this.ns;
+ parent.return_value = c;
+ parent = c;
+ break;
+
+ case "virtual-method": // not sure...
+ return;
+ /*
+ var c = new GirObject("Signal",n);
+ parent.signals.set(n,c);
+ parent = c;
+ break;
+ */
+ case "signal": // Glib:signal
+ var c = new GirObject("Signal",n.replace("-", "_"));
+ c.gparent = parent;
+ c.ns = this.ns;
+ parent.signals.set(n.replace("-", "_"),c);
+ parent = c;
+ break;
+
+
+
+ case "callback": // not sure...
+ return;
+
+
+ case "type":
+ parent.type = n;
+
+ return; // no children?
+ //break;
+
+ case "method":
+ var c = new GirObject("Method",n);
+ c.gparent = parent;
+ c.ns = this.ns;
+ c.propertyof = parent.name;
+ parent.methods.set(n,c);
+ parent = c;
+ break;
+
+ case "parameters":
+ var c = new GirObject("Paramset",n);
+ c.gparent = parent;
+ c.ns = this.ns;
+ parent.paramset = c;
+ parent = c;
+ break;
+
+ case "instance-parameter":
+ break;
+ // looks like this is the C first arg, that is ignored (as it is
+ // treated as 'this' )
+ var c = new GirObject("Param",n);
+ c.gparent = parent;
+ c.ns = this.ns;
+ c.is_instance = true;
+ parent.params.add(c);
+ parent = c;
+ break;
+
+ case "parameter":
+ var c = new GirObject("Param",n);
+ c.gparent = parent;
+ c.ns = this.ns;
+ parent.params.add(c);
+ parent = c;
+ this.checkParamOverride(c);
+ break;
+
+ case "property":
+ case "field":
+ var c = new GirObject("Prop",n.replace("-", "_"));
+ c.gparent = parent;
+ c.ns = this.ns;
+ c.propertyof = parent.name;
+ parent.props.set(n.replace("-", "_"),c);
+ parent = c;
+ break;
+
+ case "function":
+ var c = new GirObject("Function",n);
+ c.gparent = parent;
+ c.ns = this.ns;
+ parent.methods.set(n,c);
+ parent = c;
+ break;
+
+ case "array":
+ parent.is_array = true;
+ break; // type is added soon..
+
+ case "varargs":
+ parent.is_varargs= true;
+ return;
+
+ case "constant":
+ var c = new GirObject("Const",n);
+ c.gparent = parent;
+ c.value = element->get_prop("value");
+ c.ns = this.ns;
+ parent.consts.set(n,c);
+ parent = c;
+ return;
+ //break;
+ case "bitfield":
+ case "enumeration":
+ var c = new GirObject("Enum",n);
+ c.gparent = parent;
+ c.ns = this.ns;
+ parent.consts.set(n,c);
+
+ parent = c;
+ break;
+
+ case "member":
+ var c = new GirObject("EnumMember",n);
+ c.gparent = parent;
+ c.ns = this.ns;
+ c.value = element->get_prop("value");
+ parent.consts.set(n,c);
+ return;
+ break;
+
+
+ case "doc-deprecated":
+ return;
+
+ case "record": // struct?
+ return;
+
+
+ return;
+ case "prerequisite": // ignore?
+ return;
+ case "union": // ignore?
+ return;
+ default:
+ print("UNHANDLED Gir file element: " + element->name +"\n");
+ return;
+ }
+ /*
+ if (element->name == "signal") {
+ path += ".signal";
+ }
+
+
+ if (element->name == "return-value") {
+ path += ".return-value";
+ }
+ print(path + ":" + element->name + "\n");
+ */
+ //var d = getAttribute(element,'doc');
+ //if (d) {
+ // Seed.print(path + ':' + d);
+ // ret[path] = d;
+ //}
+ for (Xml.Node* iter = element->children; iter != null; iter = iter->next) {
+ if (iter->type == Xml.ElementType.TEXT_NODE) {
+ continue;
+ }
+ this.walk(iter, parent);
+ }
+
+ }
+ public string doc(string what)
+ {
+ var ar = what.split(".");
+ var cls = this.classes.get(ar[1]);
+ if (ar.length == 2) {
+ return cls.doctxt != null ? cls.doctxt : "";
+ }
+ // return the property.. by default..
+ var pr = cls.props.get(ar[2]);
+ return pr.doctxt != null ? pr.doctxt : "";
+
+ }
+
+
+
+ public void checkParamOverride(GirObject c)
+ {
+ var parset = c.gparent;
+ if (parset == null || parset.nodetype != "Paramset") {
+ return;
+ }
+ var method = parset.gparent;
+ if (method == null || method.nodetype != "Ctor") {
+ return;
+ }
+ var cls = method.gparent;
+ if (cls == null || cls.nodetype != "Class") {
+ return;
+ }
+
+
+
+ c.name = this.fetchOverride( cls.name, method.name, c.name);
+ }
+ public static bool overrides_loaded = false;
+ public static Gee.HashMap<string,string> overrides;
+
+ public string fetchOverride( string cls, string method, string param)
+ {
+ // overrides should be in a file Gir.overides
+ // in that "Gtk.Label.new.str" : "label"
+ this.loadOverrides();
+ var key = "%s.%s.%s".printf(cls,method,param);
+ //print("Chekcing for key %s\n", key);
+ if (!overrides.has_key(key)) {
+ return param;
+ }
+ return overrides.get(key);
+
+
+ }
+ public void loadOverrides()
+ {
+ if (overrides_loaded) {
+ return;
+ }
+
+ var pa = new Json.Parser();
+ pa.load_from_file(Builder4.Application.configDirectory() + "/resources/Gir.overides");
+ var node = pa.get_root();
+
+ if (node.get_node_type () != Json.NodeType.OBJECT) {
+ throw new GirError.INVALID_FORMAT ("Error loading gir.overides : Unexpected element type %s", node.type_name ());
+ }
+ overrides = new Gee.HashMap<string,string>();
+
+
+ var obj = node.get_object ();
+
+
+ obj.foreach_member((o , key, value) => {
+ //print(key+"\n");
+
+ var v = obj.get_string_member(key);
+
+
+ overrides.set(key, v);
+
+ });
+
+ overrides_loaded = true;
+
+
+
+ }
+ }
+
+
+}
projects / app.Builder.js / blobdiff