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

   1 namespace Palete {
   2
   3
   4
   5
   6
   7     public class Introspect.El : Object
   8     {
   9         public enum eltype {
  10             NS,
  11             CLASS,
  12             METHOD,
  13             PROP
  14         }
  15
  16
  17         public eltype type;
  18     }
  19
  20
  21     public class Gtk : Palete {
  22
  23
  24         public Gtk()
  25         {
  26
  27
  28
  29             base();
  30             this.name = "Gtk";
  31
  32                         //this.load();
  33             // various loader methods..
  34               //this.map = [];
  35             //this.load();
  36             //this.proplist = {};
  37             //this.comments = { };
  38             // no parent...
  39         }
  40
  41         public override void  load () {
  42
  43                 this.loadUsageFile("/usr/share/appBuilder/GtkUsage.txt");
  44
  45
  46         }
  47
  48         public string doc(string what) {
  49             var ns = what.split(".")[0];
  50             var gir =  Gir.factory(ns);
  51                         return   gir.doc(what);
  52
  53             //return typeof(this.comments[ns][what]) == 'undefined' ?  '' : this.comments[ns][what];
  54         }
  55
  56                 // does not handle implements...
  57
  58         public override Gee.HashMap<string,GirObject> getPropertiesFor(string ename, string type)
  59         {
  60             //print("Loading for " + ename);
  61
  62
  63
  64                         // if (typeof(this.proplist[ename]) != 'undefined') {
  65                 //print("using cache");
  66              //   return this.proplist[ename][type];
  67             //}
  68             // use introspection to get lists..
  69
  70             var es = ename.split(".");
  71                         var gir = Gir.factory(es[0]);
  72
  73                         var cls = gir.classes.get(es[1]);
  74                         if (cls == null) {
  75                                 var ret = new Gee.HashMap<string,GirObject>();
  76                                 return ret;
  77                                 //throw new Error.INVALID_VALUE( "Could not find class: " + ename);
  78
  79                         }
  80
  81                         //cls.parseProps();
  82                         //cls.parseSignals(); // ?? needed for add handler..
  83                         //cls.parseMethods(); // ?? needed for ??..
  84                         //cls.parseConstructors(); // ?? needed for ??..
  85
  86                         cls.overlayParent();
  87
  88                         switch  (type) {
  89                                 case "props":
  90                                         return cls.props;
  91                                 case "signals":
  92                                         return cls.signals;
  93                                 case "methods":
  94                                         return cls.methods;
  95                                 case "ctors":
  96                                         return cls.ctors;
  97                                 default:
  98                                         throw new Error.INVALID_VALUE( "getPropertiesFor called with: " + type);
  99                                         //var ret = new Gee.HashMap<string,GirObject>();
 100                                         //return ret;
 101
 102                         }
 103
 104
 105                         //cls.overlayInterfaces(gir);
 106
 107
 108
 109         }
 110                 public string[] getInheritsFor(string ename)
 111                 {
 112                         string[] ret = {};
 113                         var es = ename.split(".");
 114                         var gir = Gir.factory(es[0]);
 115
 116                         var cls = gir.classes.get(es[1]);
 117                         if (cls == null) {
 118                                 return ret;
 119                         }
 120                         return cls.inheritsToStringArray();
 121
 122
 123                 }
 124         /*
 125         genParams: function(sig, meth)
 126         {
 127             var args = ['self'];
 128             var ret = "\n";
 129             meth.ret_type = this.typeToName(GIRepository.callable_info_get_return_type(sig));
 130             // might be a numbeR??
 131             meth.params = [];
 132             for(var a_i  =0; a_i   < GIRepository.callable_info_get_n_args(sig); a_i++) {
 133                 var arg = GIRepository.callable_info_get_arg(sig, a_i);
 134
 135                 meth.params.push({
 136                     name  : arg.get_name(),
 137                     type : this.typeToName(arg.get_type(), true)
 138                 });
 139             }
 140
 141
 142
 143
 144         },
 145         genSkel: function(sig) // should really use genParams...
 146         {
 147             var args = ['self'];
 148             var ret = "\n";
 149             var ret_type = this.typeToName(GIRepository.callable_info_get_return_type(sig));
 150             // might be a numbeR??
 151             if (ret_type == 'boolean') {
 152                 ret = "    return false;\n";
 153             }
 154             for(var a_i  =0; a_i   < GIRepository.callable_info_get_n_args(sig); a_i++) {
 155                 var arg = GIRepository.callable_info_get_arg(sig, a_i);
 156
 157                 args.push(arg.get_name());
 158             }
 159             return 'function (' + args.join(', ') + ") {\n" + ret + "}";
 160
 161
 162
 163         },
 164         typeToName  : function (type_info, allow_iface) // find type for properties or arguments.
 165         {
 166            var ty = GIRepository.type_tag_to_string( GIRepository.type_info_get_tag(type_info));
 167
 168             if ((ty == 'void') && GIRepository.type_info_is_pointer(type_info)) {
 169                 return false;
 170             }
 171             if (ty == 'array') {
 172                 return false; // unspported
 173             }
 174             if (ty != 'interface') {
 175                 return ty;
 176             }
 177             // we can accept enum types here..
 178             var interface_info = GIRepository.type_info_get_interface(type_info);
 179             var interface_type = interface_info.get_type();
 180
 181             if (!allow_iface && interface_type != GIRepository.InfoType.ENUM) {
 182                 return false;
 183             }
 184             return interface_info.get_namespace() + '.' + interface_info.get_name();
 185
 186         },
 187         /**
 188          * merge two proprety arrays' ignoring what's overrriden.
 189          *
 190          * /
 191
 192
 193         overrides : function (top, bottom)
 194         {
 195             function inTop(b)
 196             {
 197                 return !top.every(function(t) {
 198                     if (t.name == b.name) {
 199                         return false;
 200                     }
 201                     return true;
 202                 });
 203             }
 204             bottom.forEach(function(e) {
 205                 if (!inTop(e)) {
 206                     top.push(e);
 207                 }
 208             });
 209
 210         },
 211
 212         /**
 213          * guess type..
 214          *
 215          * /
 216         findType : function (data, prop, value)
 217         {
 218             // specials??
 219             if ((prop == '|xns') || (prop == 'xtype'))  {
 220                 return 'string';
 221             }
 222
 223             var qname = this.guessName(data);
 224             if (prop[0] == '|') {
 225                 prop= prop.substring(1);
 226             }
 227
 228             var prs = this.getPropertiesFor(qname, 'props');
 229             var ret = false;
 230             prs.forEach(function(e) {
 231                 if (ret !== false) {
 232                     return; // got it.
 233                 }
 234                 if (e.name == prop) {
 235                     ret = e;
 236                 }
 237
 238             });
 239             if (!ret) {
 240                 return Base.prototype.findType(data, prop,value);
 241             }
 242
 243             // got the type
 244             return ret.type;
 245         },
 246
 247         findOptions : function(ename)
 248         {
 249
 250             var es = ename.split('.');
 251             if (es.length !=2) {
 252                 return Base.prototype.findOptions(ename);
 253             }
 254             var gi = GIRepository.Repository.get_default();
 255             var bi = gi.find_by_name(es[0], es[1]);
 256             var etype = GIRepository.object_info_get_type(bi);
 257             if (etype != GIRepository.InfoType.ENUM) {
 258                 console.log("Options not handled yet!!!");
 259                 return false;
 260             }
 261             var ret = [];
 262             // got an enum.. let's return the values..
 263             for(var i =0; i < bi.get_n_values(); i++) {
 264
 265                   var prop = bi.get_value(i);
 266
 267
 268                   ret.push( ename + '.' + prop.get_name().toUpperCase() )
 269             }
 270             return ret;
 271         },
 272         /**
 273          * determine the packing types..
 274          * /
 275         getDefaultPack: function(pname, cname) {
 276             var list = this.getPackingList(pname,cname);
 277            // console.dump(list);
 278
 279
 280             if (!list.every(function(e) { return e.name != 'add'; })) {
 281                 return 'add'; // add is in our list..?? what about args..?!?
 282             }
 283             function toRet(e) {
 284                 var ret = [e.name];
 285                 e.params.forEach(function(p,i) {
 286                     if (ret === false) { return; } // skip broken..
 287                     if (i==0) { return; } // skip first..
 288                     if (p.type == 'boolean') {
 289                         ret.push('false');
 290                         return;
 291                     }
 292                     if (p.type == 'number') {
 293                         ret.push('0');
 294                         return;
 295                     }
 296                     if (p.type == 'uint') {
 297                         ret.push('0');
 298                         return;
 299                     }
 300                     ret = false; // invalid!
 301                 });
 302                 return ret === false ? false : ret.join(',');
 303             };
 304             var packret = false;
 305             list.every(function(e) {
 306
 307                 packret = toRet(e);
 308                 //print("DEFAULT PACK TEST : " + e.name + " : " +packret);
 309                 if (packret !== false) {
 310                     return false;
 311                 }
 312                 return true; // continue
 313             });
 314             //print("DEFAULT PACK: " + packret);
 315             // should we do best match..?
 316             return packret;
 317         },
 318         /**
 319          * get packing list..
 320          * /
 321         getPackingList :function (pname, cname)
 322         {
 323             var funcs = this.getPropertiesFor(pname,'methods');
 324             //print("getPackingList : ALL FUNCS");
 325             //console.dump(funcs);
 326             var ret = [];
 327             var _this = this;
 328             // let's assume top down...
 329             var inherits = [ cname ];
 330             inherits.push.apply(inherits, this.getPropertiesFor(cname,'inherits'));
 331             funcs.forEach(function(m) {
 332                 if (m.params.length && (typeof(m.params[0].type) == 'string') &&
 333                     inherits.indexOf(m.params[0].type) > -1) {
 334                     ret.push(m);
 335                 }
 336             });
 337             return ret;
 338         }
 339       */
 340
 341                 public override void fillPack(JsRender.Node node,JsRender.Node parent)
 342                 {
 343
 344                         string inherits = " " + string.joinv(" ", this.getInheritsFor (node.fqn())) + " ";
 345                         // parent.fqn() method ( node.fqn()
 346                         var methods = this.getPropertiesFor (parent.fqn(), "methods");
 347
 348                         var map = methods.map_iterator();
 349                         while (map.next()) {
 350                                 var n = map.get_key();
 351                                 var meth = map.get_value();
 352                                 if (meth.paramset == null || meth.paramset.params.length() < 1) {
 353                                         continue;
 354                                 }
 355                                 var fp = meth.paramset.params.nth_data(0);
 356                                 var type = Gir.fqtype(fp.type, meth.ns);
 357                                 if (!inherits.contains(" " + type + " ")) {
 358                                         continue;
 359                                 }
 360                                 var pack = meth.name;
 361                                 for(var i =1; i < meth.paramset.params.length(); i++) {
 362                                         var ty = Gir.fqtype(meth.paramset.params.nth_data(i).type, meth.ns);
 363                                         pack += "," + Gir.guessDefaultValueForType(ty);
 364                                 }
 365                                 node.set("pack", pack);
 366                                 return;
 367
 368                         }
 369
 370
 371                 }
 372
 373
 374     }
 375 }
 376