git.roojs.org Git - app.Builder.js/blob - src/Palete/Gir.vala

   1
   2 // 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
   3 /*
   4 public static int main (string[] args) {
   5
   6     var g = Palete.Gir.factory("Gtk");
   7         var test = g.classes.get("ToolButton");
   8
   9
  10     var generator = new Json.Generator ();
  11     var n = new Json.Node(Json.NodeType.OBJECT);
  12     n.set_object(test.toJSON());
  13     generator.set_root(n);
  14     generator.indent = 4;
  15     generator.pretty = true;
  16
  17     print(generator.to_data(null));
  18     return 0;
  19 }
  20  */
  21 namespace Palete {
  22         public errordomain GirError {
  23                 INVALID_TYPE,
  24                 NEED_IMPLEMENTING,
  25                 MISSING_FILE,
  26                 INVALID_VALUE,
  27                 INVALID_FORMAT
  28         }
  29         public class GirObject: Object {
  30                 public string name;
  31                 public string ns;
  32                 public string propertyof;
  33                 public string type;
  34                 public string nodetype;
  35                 public string  package;
  36
  37                 public GirObject paramset = null;
  38                 public GirObject return_value = null;
  39
  40                 public bool is_instance;
  41                 public bool is_array;
  42                 public bool  is_varargs;
  43                 public bool  ctor_only; // specially added ctor properties..
  44                 public  string parent;
  45                 public  string value;
  46                 // to be filled in...
  47
  48                 public  string sig;
  49
  50                 bool is_overlaid;
  51
  52                 public  GirObject gparent;
  53                 public Gee.ArrayList<GirObject> params;
  54                 public Gee.ArrayList<string> implements;
  55                 public Gee.ArrayList<string> inherits; // full list of all classes and interfaces...
  56                 public Gee.HashMap<string,GirObject> ctors;
  57                 public Gee.HashMap<string,GirObject> methods;
  58                 public Gee.HashMap<string,string>    includes;
  59                 public Gee.HashMap<string,GirObject> classes;
  60                 public Gee.HashMap<string,GirObject> props;
  61                 public Gee.HashMap<string,GirObject> consts;
  62                 public Gee.HashMap<string,GirObject> signals;
  63                 public string doctxt;
  64
  65
  66
  67                 public GirObject(string nodetype, string n)
  68                 {
  69                         this.nodetype = nodetype;
  70                         this.name = n;
  71                         this.ns = "";
  72                         this.parent = "";
  73                         this.type = "";
  74                         this.propertyof = "";
  75                         this.is_array = false;
  76                         this.is_instance = false;
  77                         this.is_varargs = false;
  78                         this.ctor_only  =false;
  79                         this.doctxt = "";
  80
  81                         this.sig = "";
  82
  83                         this.gparent = null;
  84
  85                         this.implements = new Gee.ArrayList<string>();
  86                         this.inherits  = new Gee.ArrayList<string>(); // list of all ancestors. (interfaces and parents)
  87                         this.includes   = new Gee.HashMap<string,string>();
  88
  89                         this.params = new Gee.ArrayList<GirObject>();
  90                         this.ctors      = new Gee.HashMap<string,GirObject>();
  91                         this.methods    =new Gee.HashMap<string,GirObject>();
  92
  93                         this.classes    = new Gee.HashMap<string,GirObject>();
  94                         this.props      = new Gee.HashMap<string,GirObject>();
  95                         this.consts     = new Gee.HashMap<string,GirObject>();
  96                         this.signals    = new Gee.HashMap<string,GirObject>();
  97                         this.is_overlaid = false;
  98                         this.paramset = null;
  99                 }
 100
 101                 public string[] inheritsToStringArray()
 102                 {
 103                         string[] ret = {};
 104                         for(var i =0;i< this.inherits.size; i++) {
 105                                 ret += this.inherits.get(i);
 106                         }
 107                         return ret;
 108
 109                 }
 110
 111
 112                 public void  overlayParent()
 113                 {
 114
 115                         if (this.parent.length < 1 || this.is_overlaid) {
 116                                 this.is_overlaid = true;
 117                                 return;
 118                         }
 119                         // print("Overlaying " +this.name + " with " + this.parent + "\n");
 120
 121                         var pcls = this.clsToObject( this.parent);
 122                         if (pcls == null) {
 123                                 throw new GirError.INVALID_VALUE("Could not find class : " +
 124                                         this.parent + " of " + this.name  + " in " + this.ns);
 125                         }
 126
 127                         pcls.overlayParent( );
 128                         this.copyFrom(pcls,false);
 129                         for(var i=0; i < this.implements.size; i++) {
 130                                 var clsname = this.implements.get(i);
 131                                 var picls = this.clsToObject(clsname);
 132                                 this.copyFrom(picls,true);
 133                         }
 134                         this.is_overlaid = true;
 135
 136                 }
 137
 138                 public void overlayCtorProperties()
 139                 {
 140                         //print("Check overlay Ctor %s\n", this.name);
 141                         if (!this.ctors.has_key("new")) {
 142                                 return;
 143                         }
 144                         var ctor = this.ctors.get("new");
 145                         if (ctor.paramset == null || ctor.paramset.params.size < 1) {
 146                                 return;
 147                         }
 148                         //print("Found Ctor\n");
 149                         var iter = ctor.paramset.params.list_iterator();
 150                         while (iter.next()) {
 151                                 var n = iter.get().name;
 152
 153                                 if (this.props.has_key(n)) {
 154                                         continue;
 155                                 }
 156                                 if (n == "...") {
 157                                         continue;
 158                                 }
 159                                 //print("Adding prop %s\n", n);
 160
 161                                 // it's a new prop..
 162                                 var c = new GirObject("Prop",n);
 163                                 c.gparent = this;
 164                                 c.ns = this.ns;
 165                                 c.propertyof = this.name;
 166                                 c.type = iter.get().type;
 167                                 c.ctor_only = true;
 168                                 this.props.set(n, c);
 169                         }
 170
 171
 172                 }
 173
 174
 175
 176                 public GirObject clsToObject(string in_pn)
 177                 {
 178                         var pn = in_pn;
 179                         var gir = Gir.factory (this.ns);
 180                         if (in_pn.contains(".")) {
 181                                 gir =  Gir.factory(in_pn.split(".")[0]);
 182                                 pn = in_pn.split(".")[1];
 183                         }
 184
 185                         return gir.classes.get(pn);
 186
 187
 188                 }
 189                 public string fqn() {
 190                         // not sure if fqn really is correct here...
 191                         //
 192                         return this.nodetype == "Class" || this.nodetype=="Interface"
 193                                         ? this.name : (this.ns + this.name);
 194                 }
 195
 196                 public void copyFrom(GirObject pcls, bool is_interface)
 197                 {
 198
 199                         this.inherits.add(pcls.fqn());
 200
 201                         var liter = pcls.inherits.list_iterator();
 202                         while(liter.next()) {
 203                         if (this.inherits.contains(liter.get())) {
 204                                         continue;
 205                                 }
 206                                 this.inherits.add(liter.get());
 207                         }
 208
 209
 210                         var iter = pcls.methods.map_iterator();
 211                         while(iter.next()) {
 212                         if (null != this.methods.get(iter.get_key())) {
 213                                         continue;
 214                                 }
 215
 216                                 this.methods.set(iter.get_key(), iter.get_value());
 217                         }
 218
 219                         iter = pcls.props.map_iterator();
 220                         while(iter.next()) {
 221                                  if (null != this.props.get(iter.get_key())) {
 222                                         continue;
 223                                 }
 224
 225                                 this.props.set(iter.get_key(), iter.get_value());
 226                         }
 227
 228                         iter = pcls.signals.map_iterator();
 229                         while(iter.next()) {
 230                                 if (null != this.signals.get(iter.get_key())) {
 231                                                 continue;
 232                                 }
 233
 234                                 this.signals.set(iter.get_key(), iter.get_value());
 235                         }
 236                 }
 237
 238                 public Json.Object toJSON()
 239                 {
 240                     var r = new Json.Object();
 241                     r.set_string_member("nodetype", this.nodetype);
 242                     r.set_string_member("name", this.name);
 243                                 if (this.propertyof.length > 0) {
 244                         r.set_string_member("of", this.propertyof);
 245                     }
 246                     if (this.type.length > 0) {
 247                         r.set_string_member("type", this.type);
 248                     }
 249                     if (this.parent != null && this.parent.length > 0) {
 250                         r.set_string_member("parent", this.parent);
 251                     }
 252                     if (this.sig.length > 0) {
 253                         r.set_string_member("sig", this.sig);
 254                     }
 255
 256                     // is_arary / is_instance / is_varargs..
 257
 258
 259                         if (this.inherits.size > 0) {
 260                         r.set_array_member("inherits", this.toJSONArrayString(this.inherits));
 261                     }
 262
 263                     if (this.implements.size > 0) {
 264                         r.set_array_member("implements", this.toJSONArrayString(this.implements));
 265                     }
 266
 267                     if (this.params.size > 0) {
 268                         r.set_array_member("params", this.toJSONArrayObject(this.params));
 269                     }
 270                     if (this.ctors.size > 0) {
 271                         r.set_object_member("ctors", this.toJSONObject(this.ctors));
 272                     }
 273                     if (this.methods.size > 0) {
 274                         r.set_object_member("methods", this.toJSONObject(this.methods));
 275                     }
 276                     if (this.includes.size > 0) {
 277                         r.set_object_member("includes", this.toJSONObjectString(this.includes));
 278                     }
 279                     if (this.classes.size > 0) {
 280                         r.set_object_member("classes", this.toJSONObject(this.classes));
 281                     }
 282                     if (this.props.size > 0) {
 283                         r.set_object_member("props", this.toJSONObject(this.props));
 284                     }
 285                     if (this.consts.size > 0) {
 286                         r.set_object_member("consts", this.toJSONObject(this.consts));
 287                     }
 288                     if (this.signals.size > 0) {
 289                         r.set_object_member("signals", this.toJSONObject(this.signals));
 290                     }
 291                     if (this.paramset != null) {
 292                         r.set_object_member("paramset", this.paramset.toJSON());
 293                     }
 294                     if (this.return_value != null) {
 295                         r.set_object_member("return_value", this.return_value.toJSON());
 296                     }
 297                     return r;
 298                 }
 299                 public Json.Object toJSONObject(Gee.HashMap<string,GirObject> map)
 300                 {
 301                     var r = new Json.Object();
 302                     var iter = map.map_iterator();
 303                     while(iter.next()) {
 304                         r.set_object_member(iter.get_key(), iter.get_value().toJSON());
 305                     }
 306                     return r;
 307                 }
 308                 public Json.Object  toJSONObjectString(Gee.HashMap<string,string> map)
 309                 {
 310                     var r = new Json.Object();
 311                     var iter = map.map_iterator();
 312                     while(iter.next()) {
 313                         r.set_string_member(iter.get_key(), iter.get_value());
 314                     }
 315                     return r;
 316                 }
 317                 public Json.Array toJSONArrayString(Gee.ArrayList<string> map)
 318                 {
 319                     var r = new Json.Array();
 320                     for(var i =0;i< map.size;i++) {
 321
 322                         r.add_string_element(map.get(i));
 323                     }
 324                     return r;
 325                 }
 326                 public Json.Array toJSONArrayObject(Gee.ArrayList<GirObject> map)
 327                 {
 328                     var r = new Json.Array();
 329                     for(var i =0;i< map.size;i++) {
 330
 331                         r.add_object_element(map.get(i).toJSON());
 332                     }
 333                     return r;
 334                 }
 335                 public string asJSONString()
 336                 {
 337                         var generator = new Json.Generator ();
 338                         generator.indent = 4;
 339                         generator.pretty = true;
 340                         var n = new Json.Node(Json.NodeType.OBJECT);
 341                         n.set_object(this.toJSON());
 342                         generator.set_root(n);
 343
 344                         return generator.to_data(null);
 345                 }
 346
 347
 348                 public GirObject fetchByFqn(string fqn) {
 349                         //print("Searching (%s)%s for %s\n", this.nodetype, this.name, fqn);
 350                         var bits = fqn.split(".");
 351
 352                         var ret = this.classes.get(bits[0]);
 353                         if (ret != null) {
 354                                 if (bits.length < 2) {
 355                                         return ret;
 356                                 }
 357                                 return ret.fetchByFqn(fqn.substring(bits[0].length+1));
 358                         }
 359
 360                         ret = this.ctors.get(bits[0]);
 361                         if (ret != null) {
 362                                 if (bits.length < 2) {
 363                                         return ret;
 364                                 }
 365                                 return ret.fetchByFqn(fqn.substring(bits[0].length+1));
 366                         }
 367
 368                         ret = this.methods.get(bits[0]);
 369                         if (ret != null) {
 370                                 if (bits.length < 2) {
 371                                         return ret;
 372                                 }
 373                                 return ret.fetchByFqn(fqn.substring(bits[0].length+1));
 374                         }
 375                         ret = this.props.get(bits[0]);
 376                         if (ret != null) {
 377                                 if (bits.length < 2) {
 378                                         return ret;
 379                                 }
 380                                 return ret.fetchByFqn(fqn.substring(bits[0].length+1));
 381                         }
 382                         ret = this.consts.get(bits[0]);
 383                         if (ret != null) {
 384                                 if (bits.length < 2) {
 385                                         return ret;
 386                                 }
 387                                 return ret.fetchByFqn(fqn.substring(bits[0].length+1));
 388                         }
 389
 390                         ret = this.signals.get(bits[0]);
 391                         if (ret != null) {
 392                                 if (bits.length < 2) {
 393                                         return ret;
 394                                 }
 395                                 return ret.fetchByFqn(fqn.substring(bits[0].length+1));
 396                         }
 397                         if (this.paramset == null) {
 398                                 return null;
 399                         }
 400                         var iter = this.paramset.params.list_iterator();
 401                         while (iter.next()) {
 402                                 var p = iter.get();
 403                                 if (p.name != bits[0]) {
 404                                         continue;
 405                                 }
 406                                 return p;
 407                         }
 408
 409                         // fixme - other queires? - enums?
 410                         return null;
 411                 }
 412
 413                 public string fqtype() {
 414                         return Gir.fqtypeLookup(this.type, this.ns);
 415                 }
 416         }
 417
 418
 419
 420
 421
 422         public class Gir : GirObject {
 423
 424                 static  Gee.HashMap<string,Gir> cache = null;
 425                 //Gee.Hashmap<string,what> nodes;
 426
 427
 428
 429                 public static Gir?  factory(string ns) {
 430                         if (cache == null) {
 431                                 cache = new Gee.HashMap<string,Gir>();
 432                         }
 433                         var ret = cache.get(ns);
 434                         if (ret == null) {
 435
 436                                 var add = new Gir(ns);
 437                                 cache.set(ns, add);
 438
 439                                 var iter = add.classes.map_iterator();
 440                                 while(iter.next()) {
 441                                         iter.get_value().overlayParent();
 442                                 }
 443                                 // loop again and add the ctor properties.
 444                                  iter = add.classes.map_iterator();
 445                                 while(iter.next()) {
 446                                         iter.get_value().overlayCtorProperties();
 447                                 }
 448
 449
 450                                 ret = cache.get(ns);
 451                         }
 452
 453
 454                         return ret;
 455
 456                 }
 457                 public static GirObject?  factoryFqn(string fqn)
 458                 {
 459                         var bits = fqn.split(".");
 460                         if (bits.length < 1) {
 461                                 return null;
 462                         }
 463
 464                         var f = (GirObject)factory(bits[0]);
 465
 466                         if (bits.length == 1 || f ==null) {
 467                                 return f;
 468                         }
 469                         return f.fetchByFqn(fqn.substring(bits[0].length+1)); // since classes are stored in fqn format...?
 470
 471
 472                 }
 473
 474
 475                 /**
 476                  * guess the fqn of a type == eg. gboolean or Widget etc...
 477                  */
 478                 public static string fqtypeLookup(string type, string ns) {
 479                         var g = factory(ns);
 480                         if (g.classes.has_key(type)) {
 481                                 return ns + "." + type;
 482                         }
 483                         // enums..
 484                         if (g.consts.has_key(type)) {
 485                                 return ns + "." + type;
 486                         }
 487
 488
 489                         // look at includes..
 490                         var iter = g.includes.map_iterator();
 491                         while(iter.next()) {
 492                                 // skip empty namespaces on include..?
 493                                 if ( iter.get_key() == "") {
 494                                         continue;
 495                                 }
 496                                 var ret = fqtypeLookup(type, iter.get_key());
 497                                 if (ret != type) {
 498                                         return ret;
 499                                 }
 500                 }
 501                         return type;
 502                 }
 503
 504
 505
 506
 507
 508                 public static string guessDefaultValueForType(string type) {
 509                         //print("guessDefaultValueForType: %s\n", type);
 510                         if (type.length < 1 || type.contains(".")) {
 511                                 return "null";
 512                         }
 513                         switch(type) {
 514                                 case "gboolean":
 515                                         return "true";
 516                                 case "guint":
 517                                         return "0";
 518                                 case "utf8":
 519                                         return "\"\"";
 520                                 default:
 521                                         return "?"+  type + "?";
 522                         }
 523
 524                 }
 525
 526
 527                 public Gir.new_empty (string ns)
 528                 {
 529                         base("Package",ns);
 530                 }
 531                 public Gir (string ns)
 532                 {
 533                         var xns = ns == "Glade" ? "Gladeui" : ns;
 534                         var gi = GI.Repository.get_default();
 535                         gi.require(xns, null, 0);
 536
 537                         var ver = gi.get_version(xns);
 538                         unowned GLib.SList<string>  pth = GI.Repository.get_search_path ();
 539                         var gir_path = pth.nth_data(0).replace("/lib/girepository-1.0", "/share/gir-1.0");
 540                         // 64bit...
 541                         gir_path = gir_path.replace("/lib/x86_64-linux-gnu/girepository-1.0", "/share/gir-1.0");
 542
 543                         //console.log(fn);
 544
 545
 546
 547                         var file  = gir_path + "/" + xns + "-" + ver + ".gir";
 548                         // print("ns: " + ns + "\n");
 549                         // print("ver: " + ver + "\n");
 550                         // print(file);
 551
 552
 553                         base("Package",ns);
 554                         this.ns = ns;
 555                         //this.nodes = new Gee.Hashmap<string,what>();
 556
 557                         var doc = Xml.Parser.parse_file (file);
 558                         var root = doc->get_root_element();
 559                         this.walk( root, (GirObject) this );
 560
 561                         delete doc;
 562
 563                 }
 564                 public void walk(Xml.Node* element, GirObject? parent)
 565                 {
 566                     var n = element->get_prop("name");
 567                         // ignore null or c:include...
 568                     if (n == null || (element->ns->prefix != null && element->ns->prefix == "c")) {
 569                                 n = "";
 570                     }
 571                     //print("%s:%s (%s ==> %s\n", element->ns->prefix , element->name , parent.name , n);
 572                     switch (element->name) {
 573                         case "repository":
 574                             break;
 575
 576                         case "include":
 577                             parent.includes.set(n, element->get_prop("version"));
 578                             break;
 579
 580                         case "package":
 581                             parent.package = n;
 582                             break;
 583
 584                         case "c:include":
 585                             break;
 586
 587                         case "namespace":
 588                             parent.name = n;
 589                             break;
 590
 591                         case "alias":
 592                             return;
 593                             //break; // not handled..
 594
 595                         case "class":
 596                                 var c = new GirObject("Class", parent.name + "." + n);
 597                                 parent.classes.set(n, c);
 598                                 c.ns = this.ns;
 599                                 c.parent = element->get_prop("parent");
 600                                 c.gparent = parent;
 601                                 if (c.parent == null) {
 602                                         c.parent = "";
 603                                 }
 604                                 parent =  c;
 605                                 break;
 606
 607                         case "interface":
 608                             var c = new GirObject("Interface", parent.name + "." + n);
 609                             c.gparent = parent;
 610                             parent.classes.set(n, c);
 611                                 c.ns = this.ns;
 612                                 c.ns = parent.name;
 613                                 c.parent = element->get_prop("parent");
 614                                 if (c.parent == null) {
 615                                         c.parent = "";
 616                                 }
 617                                 parent =  c;
 618                             break;
 619
 620
 621                         case "doc":
 622                             parent.doctxt = element->get_content();
 623                             return;
 624
 625                         case "implements":
 626                             parent.implements.add(n);
 627
 628                             break;
 629
 630                         case "constructor":
 631                             var c = new GirObject("Ctor",n);
 632                             c.ns = this.ns;
 633                             c.gparent = parent;
 634                             parent.ctors.set(n,c);
 635                             parent  = c;
 636                             break;
 637
 638                         case "return-value":
 639                             var c = new GirObject("Return", "return-value");
 640                             c.gparent = parent;
 641                             c.ns = this.ns;
 642                             parent.return_value = c;
 643                             parent =  c;
 644                             break;
 645
 646                         case "virtual-method": // not sure...
 647                             return;
 648                         /*
 649                             var c = new GirObject("Signal",n);
 650                             parent.signals.set(n,c);
 651                             parent = c;
 652                             break;
 653                         */
 654                         case "signal": // Glib:signal
 655                                 var c = new GirObject("Signal",n.replace("-", "_"));
 656                                 c.gparent = parent;
 657                                 c.ns = this.ns;
 658                                 parent.signals.set(n.replace("-", "_"),c);
 659                                 parent = c;
 660                                 break;
 661
 662
 663
 664                         case "callback": // not sure...
 665                             return;
 666
 667
 668                         case "type":
 669                             parent.type = n;
 670
 671                                                 return; // no children?
 672                             //break;
 673
 674                         case "method":
 675                                 var c = new GirObject("Method",n);
 676                                 c.gparent = parent;
 677                                 c.ns = this.ns;
 678                                 c.propertyof = parent.name;
 679                                 parent.methods.set(n,c);
 680                                 parent = c;
 681                                 break;
 682
 683                         case "parameters":
 684                             var c = new GirObject("Paramset",n);
 685                             c.gparent = parent;
 686                             c.ns = this.ns;
 687                             parent.paramset = c;
 688                             parent =  c;
 689                             break;
 690
 691                         case "instance-parameter":
 692                                         break;
 693                                         // looks  like this is the C first arg, that is ignored (as it is
 694                                         // treated as 'this' )
 695                                 var c = new GirObject("Param",n);
 696                                         c.gparent = parent;
 697                                         c.ns = this.ns;
 698                                 c.is_instance = true;
 699                                 parent.params.add(c);
 700                                 parent = c;
 701                                 break;
 702
 703                         case "parameter":
 704                                 var c = new GirObject("Param",n);
 705                                 c.gparent = parent;
 706                                 c.ns = this.ns;
 707                                 parent.params.add(c);
 708                                 parent = c;
 709                                 this.checkParamOverride(c);
 710                             break;
 711
 712                         case "property":
 713                         case "field":
 714                                 var c = new GirObject("Prop",n.replace("-", "_"));
 715                                 c.gparent = parent;
 716                                 c.ns = this.ns;
 717                                 c.propertyof = parent.name;
 718                                 parent.props.set(n.replace("-", "_"),c);
 719                                 parent = c;
 720                                 break;
 721
 722                         case "function":
 723                             var c = new GirObject("Function",n);
 724                             c.gparent = parent;
 725                             c.ns = this.ns;
 726                             parent.methods.set(n,c);
 727                             parent = c;
 728                             break;
 729
 730                         case "array":
 731                             parent.is_array = true;
 732                             break; // type is added soon..
 733
 734                         case "varargs":
 735                             parent.is_varargs= true;
 736                             return;
 737
 738                         case "constant":
 739                             var c = new GirObject("Const",n);
 740                             c.gparent = parent;
 741                             c.value = element->get_prop("value");
 742                                                 c.ns = this.ns;
 743                             parent.consts.set(n,c);
 744                             parent = c;
 745                             return;
 746                             //break;
 747                         case "bitfield":
 748                         case "enumeration":
 749                                 var c = new GirObject("Enum",n);
 750                                 c.gparent = parent;
 751                                 c.ns = this.ns;
 752                                 parent.consts.set(n,c);
 753
 754                                 parent = c;
 755                                 break;
 756
 757                         case "member":
 758                                 var c = new GirObject("EnumMember",n);
 759                                 c.gparent = parent;
 760                                 c.ns = this.ns;
 761                                 c.value = element->get_prop("value");
 762                                 parent.consts.set(n,c);
 763                                 return;
 764                                 break;
 765
 766
 767                         case "doc-deprecated":
 768                             return;
 769
 770                         case "record": // struct?
 771                             return;
 772
 773
 774                             return;
 775                         case "prerequisite": // ignore?
 776                             return;
 777                                         case "union": // ignore?
 778                             return;
 779                                         default:
 780                             print("UNHANDLED Gir file element: " + element->name +"\n");
 781                             return;
 782                     }
 783                     /*
 784                     if (element->name == "signal") {
 785                         path += ".signal";
 786                     }
 787
 788
 789                     if (element->name == "return-value") {
 790                         path += ".return-value";
 791                     }
 792                     print(path + ":"  + element->name + "\n");
 793                     */
 794                     //var d =   getAttribute(element,'doc');
 795                     //if (d) {
 796                      //   Seed.print(path + ':' + d);
 797                     //    ret[path] = d;
 798                     //}
 799                     for (Xml.Node* iter = element->children; iter != null; iter = iter->next) {
 800                         if (iter->type == Xml.ElementType.TEXT_NODE) {
 801                             continue;
 802                         }
 803                         this.walk(iter, parent);
 804                     }
 805
 806                 }
 807                 public string doc(string what)
 808                 {
 809                         var ar = what.split(".");
 810                         var cls = this.classes.get(ar[1]);
 811                         if (ar.length == 2) {
 812                                 return cls.doctxt != null ? cls.doctxt : "";
 813                         }
 814                         // return the property.. by default..
 815                         var pr = cls.props.get(ar[2]);
 816                         return pr.doctxt != null ? pr.doctxt : "";
 817
 818                 }
 819
 820
 821
 822                 public void checkParamOverride(GirObject c)
 823                 {
 824                         var parset = c.gparent;
 825                         if (parset == null || parset.nodetype != "Paramset") {
 826                                 return;
 827                         }
 828                         var method = parset.gparent;
 829                         if (method == null || method.nodetype != "Ctor") {
 830                                 return;
 831                         }
 832                         var cls = method.gparent;
 833                         if (cls == null || cls.nodetype != "Class") {
 834                                 return;
 835                         }
 836
 837
 838
 839                         c.name = this.fetchOverride( cls.name, method.name, c.name);
 840                 }
 841                 public static bool overrides_loaded = false;
 842                 public static Gee.HashMap<string,string> overrides;
 843
 844                 public string fetchOverride(  string cls, string method, string param)
 845                 {
 846                         // overrides should be in a file Gir.overides
 847                         // in that "Gtk.Label.new.str" : "label"
 848                         this.loadOverrides();
 849                         var key = "%s.%s.%s".printf(cls,method,param);
 850                         //print("Chekcing for key %s\n", key);
 851                         if (!overrides.has_key(key)) {
 852                                 return param;
 853                         }
 854                         return overrides.get(key);
 855
 856
 857                 }
 858                 public void loadOverrides(bool force = false)
 859                 {
 860                         if (overrides_loaded && ! force) {
 861                                 return;
 862                         }
 863
 864                         var pa = new Json.Parser();
 865                         pa.load_from_file(BuilderApplication.configDirectory() + "/resources/Gir.overides");
 866                         var node = pa.get_root();
 867
 868                         if (node.get_node_type () != Json.NodeType.OBJECT) {
 869                                 throw new GirError.INVALID_FORMAT ("Error loading gir.overides : Unexpected element type %s", node.type_name ());
 870                         }
 871                         overrides = new Gee.HashMap<string,string>();
 872
 873
 874                         var obj = node.get_object ();
 875
 876
 877                         obj.foreach_member((o , key, value) => {
 878                                 //print(key+"\n");
 879
 880                                 var v = obj.get_string_member(key);
 881
 882
 883                                 overrides.set(key, v);
 884
 885                         });
 886
 887                         overrides_loaded = true;
 888
 889
 890
 891                 }
 892         }
 893
 894
 895 }