git.roojs.org Git - roobuilder/blob - src/JsRender/Gtk.vala

   1 /**
   2  *
   3  *  this is the code represents a File when using the Gtk view..
   4  *
   5  *  It ues NodeToGtk
   6  *
   7  *
   8  */
   9
  10 namespace JsRender {
  11
  12
  13
  14         int gid = 1;
  15
  16
  17         public  class Gtk : JsRender
  18         {
  19
  20
  21            public Project.Gtk gproject {
  22                         get {
  23                                 return (Project.Gtk) this.project;
  24                         }
  25                         private set {}
  26                 }
  27
  28             public Gtk(Project.Project project, string path) {
  29
  30                 base( project, path);
  31                 this.xtype = "Gtk";
  32                 this.language = "vala";
  33
  34
  35                 //this.items = false;
  36                 //if (cfg.json) {
  37                 //    var jstr =  JSON.parse(cfg.json);
  38                 //    this.items = [ jstr ];
  39                 //    //console.log(cfg.items.length);
  40                 //    delete cfg.json; // not needed!
  41                 // }
  42
  43
  44
  45                 // super?!?!
  46                 this.id = "file-gtk-%d".printf(gid++);
  47                 //console.dump(this);
  48                 // various loader methods..
  49
  50                 // Class = list of arguments ... and which property to use as a value.
  51
  52
  53
  54
  55             }
  56
  57
  58             /*
  59             setNSID : function(id)
  60             {
  61
  62                 this.items[0]['*class'] = id;
  63
  64
  65             },
  66             getType: function() {
  67                 return 'Gtk';
  68             },
  69             */
  70
  71                 public   override void   removeFiles() {
  72                         var js = GLib.Path.get_dirname(this.path) +"/" +  name + ".js";
  73                         if (FileUtils.test(js, FileTest.EXISTS)) {
  74                                 GLib.FileUtils.remove(js);
  75                         }
  76                         var vala = GLib.Path.get_dirname(this.path) +"/" + name + ".vala";
  77                         if (FileUtils.test(vala, FileTest.EXISTS)) {
  78                                 GLib.FileUtils.remove(vala);
  79                         }
  80                 }
  81
  82                 public   override void  loadItems() throws GLib.Error // : function(cb, sync) == original was async.
  83                 {
  84
  85                         print("load Items!\n");
  86                         if (this.tree != null) {
  87                                 this.loaded = true;
  88
  89                                 return;
  90                         }
  91                         /*
  92                         print("load: %s\n" , this.path);
  93                         if (!GLib.FileUtils.test(this.path, GLib.FileTest.EXISTS)) {
  94                                 // new file?!?
  95                                 this.tree = null;
  96                                 this.loaded = true;
  97                                 return;
  98                         }
  99                         */
 100
 101                         var pa = new Json.Parser();
 102                         pa.load_from_file(this.path);
 103                         var node = pa.get_root();
 104
 105                         if (node.get_node_type () != Json.NodeType.OBJECT) {
 106                                 throw new Error.INVALID_FORMAT ("Unexpected element type %s", node.type_name ());
 107                         }
 108                         var obj = node.get_object ();
 109
 110                         this.name = obj.get_string_member("name");
 111
 112
 113                         if (obj.has_member("build_module")) { // should check type really..
 114                                 this.build_module = obj.get_string_member("build_module");
 115                         }
 116                         if (obj.has_member("gen_extended")) { // should check type really..
 117                                 this.gen_extended = obj.get_boolean_member("gen_extended");
 118                         }
 119
 120
 121
 122                         // load items[0] ??? into tree...
 123                         var bjs_version_str = this.jsonHasOrEmpty(obj, "bjs-version");
 124                         bjs_version_str = bjs_version_str == "" ? "1" : bjs_version_str;
 125
 126                         if (obj.has_member("items")
 127                                 &&
 128                                 obj.get_member("items").get_node_type() == Json.NodeType.ARRAY
 129                                 &&
 130                                 obj.get_array_member("items").get_length() > 0
 131                         ) {
 132                                 var ar = obj.get_array_member("items");
 133                                 var tree_base = ar.get_object_element(0);
 134                                 this.loadTree(tree_base,  int.parse(bjs_version_str));
 135                         }
 136                         this.gen_extended ?
 137                                 NodeToValaExtended.mungeFile(this) :
 138                                 NodeToValaWrapped.mungeFile(this); // force line numbering..?? should we call toSourceCode???
 139                         this.loaded = true;
 140                         this.updateUndo();
 141
 142                 }
 143
 144
 145
 146
 147
 148             public override string toSourcePreview()
 149             {
 150                         return "";
 151                 }
 152             public override void setSource(string str) {}
 153
 154             int last_source_version = -2;
 155             string last_source;
 156             public override string toSourceCode() // no seed support currently.
 157             {
 158                     if (this.version == this.last_source_version) {
 159                         GLib.debug("toSource - using Cache");
 160                         return this.last_source;
 161                 }
 162                 GLib.debug("toSource - generating %s", this.gen_extended  ? "Extended": "Wrapped");
 163
 164                     this.last_source =          this.gen_extended ?
 165                                 NodeToValaExtended.mungeFile(this) :
 166                                 NodeToValaWrapped.mungeFile(this);
 167
 168                     this.last_source_version = this.version;
 169
 170
 171
 172                     return this.last_source;
 173
 174             }
 175
 176             // this is only used by dumping code...
 177             public override string toSource() // no seed support currently.
 178             {
 179
 180                          return  this.toSourceCode();
 181
 182
 183             }
 184
 185             public override void save()
 186             {
 187                 this.saveBJS();
 188                 // this.saveJS(); - disabled at present.. project settings will probably enable this later..
 189
 190                 this.saveVala();
 191
 192
 193                 this.getLanguageServer().document_save.begin(this, (obj, res) => {
 194                         this.getLanguageServer().document_save.end(res);
 195                 });
 196                 BuilderApplication.showSpinner("spinner", "document save send");
 197             }
 198                 // ignore these calls.
 199             public override void saveHTML ( string html ) {}
 200
 201
 202             /**
 203              *  saveJS
 204              *
 205              * save as a javascript file. - not used currently
 206              * why is this not save...???
 207              *
 208
 209
 210             void saveJS()
 211             {
 212
 213                 var fn = GLib.Path.get_dirname(this.path) + "/" + this.name + ".js";
 214                 print("WRITE :%s\n " , fn);
 215                 this.writeFile(fn, this.toSource());
 216
 217             }
 218             */
 219
 220             public override string targetName()
 221             {
 222                 return GLib.Path.get_dirname(this.path) + "/" + this.name + ".vala";
 223         }
 224
 225             void  saveVala()
 226             {
 227                         if (this.tree == null) {
 228                                 return;
 229                         }
 230                         var fn = this.targetName();
 231                         GLib.debug("WRITE :%s\n " , fn);
 232                         try {
 233                                 this.writeFile(fn, this.toSourceCode());
 234                 } catch (GLib.Error e) {}
 235
 236
 237             }
 238
 239
 240             public void updateCompileGroup(string old_target, string new_target)
 241             {
 242                 if (old_target == new_target) {
 243                         return;
 244                 }
 245                 if (old_target != "") {
 246                         if (this.gproject.compilegroups.has_key(old_target)) {
 247                                 var cg = this.gproject.compilegroups.get(old_target);
 248                                 if (cg.sources.contains(this.relpath)) {
 249                                         cg.sources.remove(this.relpath);
 250                                         }
 251                                 }
 252                         }
 253                  if (new_target != "") {
 254                         if (this.gproject.compilegroups.has_key(new_target)) {
 255                                 var cg = this.gproject.compilegroups.get(new_target);
 256                                 if (!cg.sources.contains(this.relpath)) {
 257                                         cg.sources.add(this.relpath);
 258                                         }
 259                                 }
 260                         }
 261
 262
 263             }
 264
 265                 /*
 266             valaCompileCmd : function()
 267             {
 268
 269                 var fn = '/tmp/' + this.name + '.vala';
 270                 print("WRITE : " + fn);
 271                 File.write(fn, this.toVala(true));
 272
 273
 274
 275                 return ["valac",
 276                        "--pkg",  "gio-2.0",
 277                        "--pkg" , "posix" ,
 278                        "--pkg" , "gtk+-3.0",
 279                        "--pkg",  "libnotify",
 280                        "--pkg",  "gtksourceview-3.0",
 281                        "--pkg", "libwnck-3.0",
 282                        fn ,   "-o", "/tmp/" + this.name];
 283
 284
 285
 286
 287             },
 288             */
 289
 290             public override void  findTransStrings(Node? node )
 291                 {
 292                         // not yet..
 293                 }
 294
 295                 public override string toGlade()
 296                 {
 297                         return  NodeToGlade.mungeFile(this);
 298                 }
 299                 public   override string language_id()
 300                 {
 301                         return "vala";
 302                 }
 303
 304
 305
 306         }
 307 }
 308
 309
 310