editor/dconf-schema.vala

   1 public class SchemaKey
   2 {
   3     public Schema schema;
   4     public string name;
   5     public string type;
   6     public Variant default_value;
   7     public SchemaValueRange? range;
   8     public SchemaValueRange type_range;
   9     public List<SchemaChoice> choices;
  10     public string? enum_name;
  11     public string? summary;
  12     public string? description;
  13     public string? gettext_domain;
  14
  15     public SchemaKey.from_xml(Xml.Node* node, Schema schema, string? gettext_domain)
  16     {
  17         this.schema = schema;
  18         this.gettext_domain = gettext_domain;
  19
  20         for (var prop = node->properties; prop != null; prop = prop->next)
  21         {
  22             if (prop->name == "name")
  23                 name = prop->children->content;
  24             else if (prop->name == "type")
  25                 type = prop->children->content;
  26             else if (prop->name == "enum")
  27             {
  28                 type = "s";
  29                 enum_name = prop->children->content;
  30             }
  31                         else if (prop->name == "flags")
  32                                 /* TODO: support this properly */
  33                                 type = "as";
  34             else
  35                 warning ("Unknown property on <key>, %s", prop->name);
  36         }
  37
  38         //if (name == null || type == null)
  39         //    ?
  40
  41         for (var child = node->children; child != null; child = child->next)
  42         {
  43             if (child->name == "default")
  44             {
  45                 try
  46                 {
  47                     default_value = Variant.parse(new VariantType(type), child->get_content());
  48                 }
  49                 catch (VariantParseError e)
  50                 {
  51                     // ...
  52                 }
  53             }
  54             else if (child->name == "summary")
  55                 summary = child->get_content();
  56             else if (child->name == "description")
  57                 description = child->get_content();
  58             else if (child->name == "range")
  59                 range = new SchemaValueRange.from_xml(type, child);
  60             else if (child->name == "choices")
  61             {
  62                 for (var n = child->children; n != null; n = n->next)
  63                 {
  64                     if (n->type != Xml.ElementType.ELEMENT_NODE)
  65                         continue;
  66                     if (n->name != "choice")
  67                     {
  68                         warning ("Unknown child tag in <choices>, <%s>", n->name);
  69                         continue;
  70                     }
  71
  72                     string? value = null;
  73                     for (var prop = n->properties; prop != null; prop = prop->next)
  74                     {
  75                         if (prop->name == "value")
  76                             value = prop->children->content;
  77                         else
  78                             warning ("Unknown property on <choice>, %s", prop->name);
  79                     }
  80
  81                     if (value == null)
  82                     {
  83                         warning ("Ignoring <choice> with no value");
  84                         continue;
  85                     }
  86
  87                     var v = new Variant.string (value);
  88                     choices.append (new SchemaChoice(value, v));
  89                 }
  90             }
  91             else if (child->name == "aliases")
  92             {
  93                 for (var n = child->children; n != null; n = n->next)
  94                 {
  95                     if (n->type != Xml.ElementType.ELEMENT_NODE)
  96                         continue;
  97                     if (n->name != "alias")
  98                     {
  99                         warning ("Unknown child tag in <aliases>, <%s>", n->name);
 100                         continue;
 101                     }
 102
 103                     string? value = null, target = null;
 104                     for (var prop = n->properties; prop != null; prop = prop->next)
 105                     {
 106                         if (prop->name == "value")
 107                             value = prop->children->content;
 108                         else if (prop->name == "target")
 109                             target = prop->children->content;
 110                         else
 111                             warning ("Unknown property on <alias>, %s", prop->name);
 112                     }
 113
 114                     if (value == null)
 115                     {
 116                         warning ("Ignoring <alias> with no value");
 117                         continue;
 118                     }
 119                     if (target == null)
 120                     {
 121                         warning ("Ignoring <alias> with no target");
 122                         continue;
 123                     }
 124
 125                     var v = new Variant.string (target);
 126                     choices.append (new SchemaChoice(value, v));
 127                 }
 128             }
 129             else if (child->type != Xml.ElementType.TEXT_NODE && child->type != Xml.ElementType.COMMENT_NODE)
 130                 warning ("Unknown child tag in <key>, <%s>", child->name);
 131         }
 132
 133         //if (default_value == null)
 134         //    ?
 135     }
 136 }
 137
 138 public class SchemaValue : GLib.Object
 139 {
 140     public uint index;
 141     public string nick;
 142     public int value;
 143
 144     public SchemaValue(uint index, string nick, int value)
 145     {
 146         this.index = index;
 147         this.nick = nick;
 148         this.value = value;
 149     }
 150 }
 151
 152 public class SchemaChoice
 153 {
 154     public string name;
 155     public Variant value;
 156
 157     public SchemaChoice(string name, Variant value)
 158     {
 159         this.name = name;
 160         this.value = value;
 161     }
 162 }
 163
 164 public class SchemaValueRange
 165 {
 166     public Variant min;
 167     public Variant max;
 168
 169     public SchemaValueRange.from_xml(string type, Xml.Node* node)
 170     {
 171         for (var prop = node->properties; prop != null; prop = prop->next)
 172         {
 173             if (prop->name == "min")
 174             {
 175                 try
 176                 {
 177                     min = Variant.parse(new VariantType(type), prop->children->content);
 178                 }
 179                 catch (VariantParseError e)
 180                 {
 181                     // ...
 182                 }
 183             }
 184             else if (prop->name == "max")
 185             {
 186                 try
 187                 {
 188                     max = Variant.parse(new VariantType(type), prop->children->content);
 189                 }
 190                 catch (VariantParseError e)
 191                 {
 192                     // ...
 193                 }
 194             }
 195             else
 196                 warning ("Unknown property in <range>, %s", prop->name);
 197         }
 198
 199         //if (min == null || max == null)
 200         //    ?
 201     }
 202 }
 203
 204 public class SchemaEnum
 205 {
 206     public SchemaList list;
 207     public string id;
 208     public GLib.List<SchemaValue> values = new GLib.List<SchemaValue>();
 209
 210     public SchemaEnum.from_xml(SchemaList list, Xml.Node* node)
 211     {
 212         this.list = list;
 213
 214         for (var prop = node->properties; prop != null; prop = prop->next)
 215         {
 216             if (prop->name == "id")
 217                 id = prop->children->content;
 218             else
 219                 warning ("Unknown property in <enum>, %s", prop->name);
 220         }
 221
 222         //if (id = null)
 223         //    ?
 224
 225         for (var child = node->children; child != null; child = child->next)
 226         {
 227             if (child->name == "value")
 228             {
 229                 string? nick = null;
 230                 int value = -1;
 231
 232                 for (var prop = child->properties; prop != null; prop = prop->next)
 233                 {
 234                     if (prop->name == "value")
 235                         value = int.parse(prop->children->content);
 236                     else if (prop->name == "nick")
 237                         nick = prop->children->content;
 238                     else
 239                         warning ("Unknown property in enum <value>, %s", prop->name);
 240                 }
 241
 242                 //if (value < 0 || nick == null)
 243                 //    ?
 244
 245                 var schema_value = new SchemaValue (values.length(), nick, value);
 246                 values.append(schema_value);
 247             }
 248             else if (child->type != Xml.ElementType.TEXT_NODE && child->type != Xml.ElementType.COMMENT_NODE)
 249                 warning ("Unknown tag in <enum>, <%s>", child->name);
 250         }
 251
 252         //if (default_value == null)
 253         //    ?
 254     }
 255 }
 256
 257 public class SchemaFlags
 258 {
 259     public SchemaList list;
 260     public string id;
 261     public GLib.List<SchemaValue> values = new GLib.List<SchemaValue>();
 262
 263     public SchemaFlags.from_xml(SchemaList list, Xml.Node* node)
 264     {
 265         this.list = list;
 266
 267         for (var prop = node->properties; prop != null; prop = prop->next)
 268         {
 269             if (prop->name == "id")
 270                 id = prop->children->content;
 271             else
 272                 warning ("Unknown property in <flags>, %s", prop->name);
 273         }
 274
 275         //if (id = null)
 276         //    ?
 277
 278         for (var child = node->children; child != null; child = child->next)
 279         {
 280             if (child->name == "value")
 281             {
 282                 string? nick = null;
 283                 int value = -1;
 284
 285                 for (var prop = child->properties; prop != null; prop = prop->next)
 286                 {
 287                     if (prop->name == "value")
 288                         value = int.parse(prop->children->content);
 289                     else if (prop->name == "nick")
 290                         nick = prop->children->content;
 291                     else
 292                         warning ("Unknown property in flags <value>, %s", prop->name);
 293                 }
 294
 295                 //if (value < 0 || nick == null)
 296                 //    ?
 297
 298                 var schema_value = new SchemaValue (values.length(), nick, value);
 299                 values.append(schema_value);
 300             }
 301             else if (child->type != Xml.ElementType.TEXT_NODE && child->type != Xml.ElementType.COMMENT_NODE)
 302                 warning ("Unknown tag in <flags>, <%s>", child->name);
 303         }
 304
 305         //if (default_value == null)
 306         //    ?
 307     }
 308 }
 309
 310 public class Schema
 311 {
 312     public SchemaList list;
 313     public string id;
 314     public string? path;
 315     public GLib.HashTable<string, SchemaKey> keys = new GLib.HashTable<string, SchemaKey>(str_hash, str_equal);
 316
 317     public Schema.from_xml(SchemaList list, Xml.Node* node, string? gettext_domain)
 318     {
 319         this.list = list;
 320
 321         for (var prop = node->properties; prop != null; prop = prop->next)
 322         {
 323             if (prop->name == "id")
 324                 id = prop->children->content;
 325             else if (prop->name == "path")
 326                 path = prop->children->content; // FIXME: Does the path have to end with '/'?
 327             else if (prop->name == "gettext-domain")
 328                 gettext_domain = prop->children->content;
 329             else
 330                 warning ("Unknown property on <schema>, %s", prop->name);
 331         }
 332
 333         //if (id == null)
 334             //?
 335
 336         for (var child = node->children; child != null; child = child->next)
 337         {
 338             if (child->name != "key")
 339                continue;
 340             var key = new SchemaKey.from_xml(child, this, gettext_domain);
 341             keys.insert(key.name, key);
 342         }
 343     }
 344 }
 345
 346 public class SchemaList
 347 {
 348     public GLib.HashTable<string, Schema> schemas = new GLib.HashTable<string, Schema>(str_hash, str_equal);
 349     public GLib.HashTable<string, SchemaKey> keys = new GLib.HashTable<string, SchemaKey>(str_hash, str_equal);
 350     public GLib.HashTable<string, SchemaEnum> enums = new GLib.HashTable<string, SchemaEnum>(str_hash, str_equal);
 351     public GLib.HashTable<string, SchemaFlags> flags = new GLib.HashTable<string, SchemaFlags>(str_hash, str_equal);
 352
 353     public void parse_file(string path)
 354     {
 355         var doc = Xml.Parser.parse_file(path);
 356         if (doc == null)
 357             return;
 358
 359         var root = doc->get_root_element();
 360         if (root == null)
 361             return;
 362         if (root->name != "schemalist")
 363             return;
 364
 365         string? gettext_domain = null;
 366         for (var prop = root->properties; prop != null; prop = prop->next)
 367         {
 368             if (prop->name == "gettext-domain")
 369                 gettext_domain = prop->children->content;
 370         }
 371
 372         for (var node = root->children; node != null; node = node->next)
 373         {
 374             if (node->name == "schema")
 375             {
 376                 var schema = new Schema.from_xml(this, node, gettext_domain);
 377                 if (schema.path == null)
 378                 {
 379                     // FIXME: What to do here?
 380                     continue;
 381                 }
 382
 383                 foreach (var key in schema.keys.get_values())
 384                 {
 385                     string full_name = schema.path + key.name;
 386                     keys.insert(full_name, key);
 387                 }
 388                 schemas.insert(schema.id, schema);
 389             }
 390             else if (node->name == "enum")
 391             {
 392                 var enum = new SchemaEnum.from_xml(this, node);
 393                 enums.insert(enum.id, enum);
 394             }
 395             else if (node->name == "flags")
 396             {
 397                 var f = new SchemaFlags.from_xml(this, node);
 398                 flags.insert(f.id, f);
 399             }
 400             else if (node->type == Xml.ElementType.COMMENT_NODE)
 401             {
 402             }
 403             else if (node->type != Xml.ElementType.TEXT_NODE)
 404                 warning ("Unknown tag <%s>", node->name);
 405         }
 406
 407         delete doc;
 408     }
 409
 410     public void parse_override(string path)
 411     {
 412         var keyfile = new KeyFile();
 413         try
 414         {
 415             keyfile.load_from_file(path, KeyFileFlags.NONE);
 416         }
 417         catch (Error e)
 418         {
 419             warning("Failed to load override file %s: %s", path, e.message);
 420             return;
 421         }
 422
 423         foreach (var group in keyfile.get_groups())
 424         {
 425             var schema = schemas.lookup(group);
 426             if (schema == null)
 427                 continue;
 428
 429             string[] keys;
 430             try { keys = keyfile.get_keys(group); } catch (Error e) { continue; }
 431
 432             foreach (var key_name in keys)
 433             {
 434                 string value;
 435                 try { value = keyfile.get_value(group, key_name); } catch (Error e) { continue; }
 436
 437                 var key = schema.keys.lookup (key_name);
 438                 if (key == null)
 439                     continue;
 440
 441                 Variant default_value;
 442                 try
 443                 {
 444                     default_value = Variant.parse(new VariantType(key.type), value);
 445                 }
 446                 catch (VariantParseError e)
 447                 {
 448                     // ...
 449                     continue;
 450                 }
 451
 452                 key.default_value = default_value;
 453             }
 454         }
 455     }
 456
 457     public void load_directory(string dir) throws Error
 458     {
 459         var directory = File.new_for_path(dir);
 460
 461         var i = directory.enumerate_children (FileAttribute.STANDARD_NAME, 0, null);
 462         while (true)
 463         {
 464             var info = i.next_file (null);
 465             if (info == null)
 466                 break;
 467             var name = info.get_name();
 468
 469             if (name.has_suffix(".gschema.xml") || name.has_suffix(".enums.xml"))
 470                 parse_file(Path.build_filename(dir, name, null));
 471         }
 472
 473         i = directory.enumerate_children (FileAttribute.STANDARD_NAME, 0, null);
 474         while (true)
 475         {
 476             var info = i.next_file (null);
 477             if (info == null)
 478                 break;
 479             var name = info.get_name();
 480
 481             if (name.has_suffix(".override"))
 482                 parse_override(Path.build_filename(dir, name, null));
 483         }
 484     }
 485 }