editor/dconf-model.vala

   1 public class Key : GLib.Object
   2 {
   3     private SettingsModel model;
   4
   5     public Directory? parent;
   6
   7     public string name;
   8     public string full_name;
   9
  10     public SchemaKey? schema;
  11
  12     public bool has_schema
  13     {
  14         get { return schema != null; }
  15     }
  16
  17     public int index
  18     {
  19         get { return parent.keys.index (this); }
  20     }
  21
  22     public string type_string
  23     {
  24        private set {}
  25        public get
  26        {
  27            if (value != null)
  28            {
  29                if (value.is_of_type(VariantType.STRING) && has_schema && schema.enum_name != null)
  30                    return "<enum>";
  31                else
  32                    return value.get_type_string();
  33            }
  34            else
  35                return schema.type;
  36        }
  37     }
  38
  39     private Variant? _value;
  40     public Variant value
  41     {
  42         get
  43         {
  44             update_value();
  45             if (_value != null)
  46                 return _value;
  47             else
  48                 return schema.default_value;
  49         }
  50         set
  51         {
  52             _value = value;
  53             try
  54             {
  55                 model.client.write_sync(full_name, value);
  56             }
  57             catch (GLib.Error e)
  58             {
  59             }
  60             value_changed();
  61         }
  62     }
  63
  64     public Variant? get_min()
  65     {
  66         switch (value.classify ())
  67         {
  68         case Variant.Class.BYTE:
  69             return new Variant.byte(0);
  70         case Variant.Class.INT16:
  71             return new Variant.int16(int16.MIN);
  72         case Variant.Class.UINT16:
  73             return new Variant.uint16(uint16.MIN);
  74         case Variant.Class.INT32:
  75             return new Variant.int32(int32.MIN);
  76         case Variant.Class.UINT32:
  77             return new Variant.uint32(uint32.MIN);
  78         case Variant.Class.INT64:
  79             return new Variant.int64(int64.MIN);
  80         case Variant.Class.UINT64:
  81             return new Variant.uint64(uint64.MIN);
  82         case Variant.Class.DOUBLE:
  83             return new Variant.double(double.MIN);
  84         default:
  85             return null;
  86         }
  87     }
  88
  89     public Variant? get_max()
  90     {
  91         switch (value.classify ())
  92         {
  93         case Variant.Class.BYTE:
  94             return new Variant.byte(255);
  95         case Variant.Class.INT16:
  96             return new Variant.int16(int16.MAX);
  97         case Variant.Class.UINT16:
  98             return new Variant.uint16(uint16.MAX);
  99         case Variant.Class.INT32:
 100             return new Variant.int32(int32.MAX);
 101         case Variant.Class.UINT32:
 102             return new Variant.uint32(uint32.MAX);
 103         case Variant.Class.INT64:
 104             return new Variant.int64(int64.MAX);
 105         case Variant.Class.UINT64:
 106             return new Variant.uint64(uint64.MAX);
 107         case Variant.Class.DOUBLE:
 108             return new Variant.double(double.MAX);
 109         default:
 110             return null;
 111         }
 112     }
 113
 114     public bool is_default
 115     {
 116         get { update_value(); return _value == null; }
 117     }
 118
 119     public signal void value_changed();
 120
 121         void item_changed (string key)
 122     {
 123                 if ((key.has_suffix ("/") && full_name.has_prefix (key)) || key == full_name)
 124                         value_changed ();
 125         }
 126
 127     public Key(SettingsModel model, Directory parent, string name, string full_name)
 128     {
 129         this.model = model;
 130         this.parent = parent;
 131         this.name = name;
 132         this.full_name = full_name;
 133         this.schema = model.schemas.keys.lookup(full_name);
 134
 135                 model.item_changed.connect (item_changed);
 136     }
 137
 138     public void set_to_default()
 139     {
 140         if (!has_schema)
 141             return;
 142
 143         _value = null;
 144         try
 145         {
 146             model.client.write_sync(full_name, null);
 147         }
 148         catch (GLib.Error e)
 149         {
 150         }
 151         value_changed();
 152     }
 153
 154     private void update_value()
 155     {
 156         _value = model.client.read(full_name);
 157     }
 158 }
 159
 160 public class Directory : GLib.Object
 161 {
 162     private SettingsModel model;
 163
 164     public string name;
 165     public string full_name;
 166
 167     public Directory? parent;
 168
 169     private KeyModel _key_model;
 170     public KeyModel key_model
 171     {
 172         get { update_children(); if (_key_model == null) _key_model = new KeyModel(this); return _key_model; }
 173         private set {}
 174     }
 175
 176     public int index
 177     {
 178        get { return parent.children.index (this); }
 179     }
 180
 181     public GLib.HashTable<string, Directory> _child_map = new GLib.HashTable<string, Directory>(str_hash, str_equal);
 182     public GLib.List<Directory> _children = new GLib.List<Directory>();
 183     public GLib.List<Directory> children
 184     {
 185         get { update_children(); return _children; }
 186         private set { }
 187     }
 188
 189     public GLib.HashTable<string, Key> _key_map = new GLib.HashTable<string, Key>(str_hash, str_equal);
 190     private GLib.List<Key> _keys = new GLib.List<Key>();
 191     public GLib.List<Key> keys
 192     {
 193         get { update_children(); return _keys; }
 194         private set { }
 195     }
 196
 197     private bool have_children;
 198
 199     public Directory(SettingsModel model, Directory? parent, string name, string full_name)
 200     {
 201         this.model = model;
 202         this.parent = parent;
 203         this.name = name;
 204         this.full_name = full_name;
 205     }
 206
 207     public Directory get_child(string name)
 208     {
 209         Directory? directory = _child_map.lookup(name);
 210
 211         if (directory == null)
 212         {
 213             directory = new Directory(model, this, name, full_name + name + "/");
 214             _children.insert_sorted(directory, compare_directories);
 215             _child_map.insert(name, directory);
 216         }
 217
 218         return directory;
 219     }
 220
 221     private static int compare_directories(Directory a, Directory b)
 222     {
 223         return strcmp(a.name, b.name);
 224     }
 225
 226     public Key get_key(string name)
 227     {
 228         Key? key = _key_map.lookup(name);
 229
 230         if (key == null)
 231         {
 232             key = new Key(model, this, name, full_name + name);
 233             _keys.insert_sorted(key, compare_keys);
 234             _key_map.insert(name, key);
 235         }
 236
 237         return key;
 238     }
 239
 240     public static int compare_keys(Key a, Key b)
 241     {
 242         return strcmp(a.name, b.name);
 243     }
 244
 245     public void load_schema(Schema schema, string path)
 246     {
 247         if (path == "")
 248         {
 249             foreach (var schema_key in schema.keys.get_values())
 250                 get_key(schema_key.name);
 251         }
 252         else
 253         {
 254             string[] tokens = path.split("/", 2);
 255             string name = tokens[0];
 256
 257             var directory = get_child(name);
 258             directory.load_schema(schema, tokens[1]);
 259         }
 260     }
 261
 262     private void update_children()
 263     {
 264         if (have_children)
 265             return;
 266         have_children = true;
 267
 268         string[] items = model.client.list(full_name);
 269         for (int i = 0; i < items.length; i++)
 270         {
 271             string item_name = full_name + items[i];
 272
 273             if (DConf.is_dir(item_name))
 274             {
 275                 string dir_name = items[i][0:-1];
 276                 get_child(dir_name);
 277             }
 278             else
 279             {
 280                 get_key(items[i]);
 281             }
 282         }
 283     }
 284 }
 285
 286 public class KeyModel: GLib.Object, Gtk.TreeModel
 287 {
 288     private Directory directory;
 289
 290     public KeyModel(Directory directory)
 291     {
 292         this.directory = directory;
 293         foreach (var key in directory.keys)
 294             key.value_changed.connect(key_changed_cb); // FIXME: Need to delete this callbacks
 295     }
 296
 297     private void key_changed_cb(Key key)
 298     {
 299         Gtk.TreeIter iter;
 300         if (!get_iter_first(out iter))
 301             return;
 302
 303         do
 304         {
 305             if(get_key(iter) == key)
 306             {
 307                 row_changed(get_path(iter), iter);
 308                 return;
 309             }
 310         } while(iter_next(ref iter));
 311     }
 312
 313     public Gtk.TreeModelFlags get_flags()
 314     {
 315         return Gtk.TreeModelFlags.LIST_ONLY;
 316     }
 317
 318     public int get_n_columns()
 319     {
 320         return 3;
 321     }
 322
 323     public Type get_column_type(int index)
 324     {
 325         if (index == 0)
 326             return typeof(Key);
 327         else
 328             return typeof(string);
 329     }
 330
 331     private void set_iter(ref Gtk.TreeIter iter, Key key)
 332     {
 333         iter.stamp = 0;
 334         iter.user_data = key;
 335         iter.user_data2 = key;
 336         iter.user_data3 = key;
 337     }
 338
 339     public Key get_key(Gtk.TreeIter iter)
 340     {
 341         return (Key)iter.user_data;
 342     }
 343
 344     public bool get_iter(out Gtk.TreeIter iter, Gtk.TreePath path)
 345     {
 346         iter = Gtk.TreeIter();
 347
 348         if (path.get_depth() != 1)
 349             return false;
 350
 351         return iter_nth_child(out iter, null, path.get_indices()[0]);
 352     }
 353
 354     public Gtk.TreePath? get_path(Gtk.TreeIter iter)
 355     {
 356         var path = new Gtk.TreePath();
 357         path.append_index(get_key(iter).index);
 358         return path;
 359     }
 360
 361     public void get_value(Gtk.TreeIter iter, int column, out Value value)
 362     {
 363         Key key = get_key(iter);
 364
 365         if (column == 0)
 366             value = key;
 367         else if (column == 1)
 368             value = key.name;
 369         else if (column == 2)
 370         {
 371             if (key.value != null)
 372                 value = key.value.print(false);
 373             else
 374                 value = "";
 375         }
 376         else if (column == 4)
 377         {
 378             if (key.is_default)
 379                 value = Pango.Weight.NORMAL;
 380             else
 381                 value = Pango.Weight.BOLD;
 382         }
 383         else
 384             value = 0;
 385     }
 386
 387     public bool iter_next(ref Gtk.TreeIter iter)
 388     {
 389         int index = get_key(iter).index;
 390         if (index >= directory.keys.length() - 1)
 391             return false;
 392         set_iter(ref iter, directory.keys.nth_data(index+1));
 393         return true;
 394     }
 395
 396     public bool iter_children(out Gtk.TreeIter iter, Gtk.TreeIter? parent)
 397     {
 398         iter = Gtk.TreeIter();
 399
 400         if (parent != null || directory.keys.length() == 0)
 401             return false;
 402         set_iter(ref iter, directory.keys.nth_data(0));
 403
 404         return true;
 405     }
 406
 407     public bool iter_has_child(Gtk.TreeIter iter)
 408     {
 409         return false;
 410     }
 411
 412     public int iter_n_children(Gtk.TreeIter? iter)
 413     {
 414         if (iter == null)
 415             return (int)directory.keys.length();
 416         else
 417             return 0;
 418     }
 419
 420     public bool iter_nth_child(out Gtk.TreeIter iter, Gtk.TreeIter? parent, int n)
 421     {
 422         iter = Gtk.TreeIter();
 423
 424         if (parent != null)
 425             return false;
 426
 427         if (n >= directory.keys.length())
 428             return false;
 429         set_iter(ref iter, directory.keys.nth_data(n));
 430         return true;
 431     }
 432
 433     public bool iter_parent(out Gtk.TreeIter iter, Gtk.TreeIter child)
 434     {
 435         iter = Gtk.TreeIter();
 436         return false;
 437     }
 438
 439     public void ref_node(Gtk.TreeIter iter)
 440     {
 441         get_key(iter).ref();
 442     }
 443
 444     public void unref_node(Gtk.TreeIter iter)
 445     {
 446         get_key(iter).unref();
 447     }
 448 }
 449
 450 public class EnumModel: GLib.Object, Gtk.TreeModel
 451 {
 452     private SchemaEnum schema_enum;
 453
 454     public EnumModel(SchemaEnum schema_enum)
 455     {
 456         this.schema_enum = schema_enum;
 457     }
 458
 459     public Gtk.TreeModelFlags get_flags()
 460     {
 461         return Gtk.TreeModelFlags.LIST_ONLY;
 462     }
 463
 464     public int get_n_columns()
 465     {
 466         return 2;
 467     }
 468
 469     public Type get_column_type(int index)
 470     {
 471         if (index == 0)
 472             return typeof(string);
 473         else
 474             return typeof(int);
 475     }
 476
 477     private void set_iter(ref Gtk.TreeIter iter, SchemaValue value)
 478     {
 479         iter.stamp = 0;
 480         iter.user_data = value;
 481         iter.user_data2 = value;
 482         iter.user_data3 = value;
 483     }
 484
 485     public SchemaValue get_enum_value(Gtk.TreeIter iter)
 486     {
 487         return (SchemaValue)iter.user_data;
 488     }
 489
 490     public bool get_iter(out Gtk.TreeIter iter, Gtk.TreePath path)
 491     {
 492         iter = Gtk.TreeIter();
 493
 494         if (path.get_depth() != 1)
 495             return false;
 496
 497         return iter_nth_child(out iter, null, path.get_indices()[0]);
 498     }
 499
 500     public Gtk.TreePath? get_path(Gtk.TreeIter iter)
 501     {
 502         var path = new Gtk.TreePath();
 503         path.append_index((int)get_enum_value(iter).index);
 504         return path;
 505     }
 506
 507     public void get_value(Gtk.TreeIter iter, int column, out Value value)
 508     {
 509         if (column == 0)
 510             value = get_enum_value(iter).nick;
 511         else if (column == 1)
 512             value = get_enum_value(iter).value;
 513         else
 514             value = 0;
 515     }
 516
 517     public bool iter_next(ref Gtk.TreeIter iter)
 518     {
 519         uint index = get_enum_value(iter).index;
 520         if (index >= schema_enum.values.length () - 1)
 521             return false;
 522         set_iter(ref iter, schema_enum.values.nth_data(index + 1));
 523         return true;
 524     }
 525
 526     public bool iter_children(out Gtk.TreeIter iter, Gtk.TreeIter? parent)
 527     {
 528         iter = Gtk.TreeIter();
 529
 530         if (parent != null || schema_enum.values.length() == 0)
 531             return false;
 532
 533         set_iter(ref iter, schema_enum.values.nth_data(0));
 534
 535         return true;
 536     }
 537
 538     public bool iter_has_child(Gtk.TreeIter iter)
 539     {
 540         return false;
 541     }
 542
 543     public int iter_n_children(Gtk.TreeIter? iter)
 544     {
 545         if (iter == null)
 546             return (int) schema_enum.values.length();
 547         else
 548             return 0;
 549     }
 550
 551     public bool iter_nth_child(out Gtk.TreeIter iter, Gtk.TreeIter? parent, int n)
 552     {
 553         iter = Gtk.TreeIter();
 554
 555         if (parent != null)
 556             return false;
 557
 558         if (n >= schema_enum.values.length())
 559             return false;
 560         set_iter(ref iter, schema_enum.values.nth_data(n));
 561         return true;
 562     }
 563
 564     public bool iter_parent(out Gtk.TreeIter iter, Gtk.TreeIter child)
 565     {
 566         iter = Gtk.TreeIter();
 567         return false;
 568     }
 569
 570     public void ref_node(Gtk.TreeIter iter)
 571     {
 572         get_enum_value(iter).ref();
 573     }
 574
 575     public void unref_node(Gtk.TreeIter iter)
 576     {
 577         get_enum_value(iter).unref();
 578     }
 579 }
 580
 581 public class SettingsModel: GLib.Object, Gtk.TreeModel
 582 {
 583     public SchemaList schemas;
 584
 585     public DConf.Client client;
 586     private Directory root;
 587
 588         public signal void item_changed (string key);
 589
 590         void watch_func (DConf.Client client, string path, string[] items, string? tag) {
 591                 foreach (var item in items) {
 592                         item_changed (path + item);
 593                 }
 594         }
 595
 596     public SettingsModel()
 597     {
 598         client = new DConf.Client ();
 599         client.changed.connect (watch_func);
 600         root = new Directory(this, null, "/", "/");
 601         client.watch_sync ("/");
 602
 603         schemas = new SchemaList();
 604         try
 605         {
 606             var dirs = GLib.Environment.get_system_data_dirs();
 607
 608             /* Walk directories in reverse so the schemas in the
 609              * directory which appears first in the XDG_DATA_DIRS are
 610              * not overridden. */
 611             for (int i = dirs.length - 1; i >= 0; i--)
 612             {
 613                 var path = Path.build_filename (dirs[i], "glib-2.0", "schemas");
 614                 if (File.new_for_path (path).query_exists ())
 615                     schemas.load_directory (path);
 616             }
 617
 618             var dir = GLib.Environment.get_variable ("GSETTINGS_SCHEMA_DIR");
 619             if (dir != null)
 620                 schemas.load_directory(dir);
 621         } catch (Error e) {
 622             warning("Failed to parse schemas: %s", e.message);
 623         }
 624
 625         /* Add keys for the values in the schemas */
 626         foreach (var schema in schemas.schemas.get_values())
 627             root.load_schema(schema, schema.path[1:schema.path.length]);
 628     }
 629
 630     public Gtk.TreeModelFlags get_flags()
 631     {
 632         return 0;
 633     }
 634
 635     public int get_n_columns()
 636     {
 637         return 2;
 638     }
 639
 640     public Type get_column_type(int index)
 641     {
 642         if (index == 0)
 643             return typeof(Directory);
 644         else
 645             return typeof(string);
 646     }
 647
 648     private void set_iter(ref Gtk.TreeIter iter, Directory directory)
 649     {
 650         iter.stamp = 0;
 651         iter.user_data = directory;
 652         iter.user_data2 = directory;
 653         iter.user_data3 = directory;
 654     }
 655
 656     public Directory get_directory(Gtk.TreeIter? iter)
 657     {
 658         if (iter == null)
 659             return root;
 660         else
 661             return (Directory)iter.user_data;
 662     }
 663
 664     public bool get_iter(out Gtk.TreeIter iter, Gtk.TreePath path)
 665     {
 666         iter = Gtk.TreeIter();
 667
 668         if (!iter_nth_child(out iter, null, path.get_indices()[0]))
 669             return false;
 670
 671         for (int i = 1; i < path.get_depth(); i++)
 672         {
 673             Gtk.TreeIter parent = iter;
 674             if (!iter_nth_child(out iter, parent, path.get_indices()[i]))
 675                 return false;
 676         }
 677
 678         return true;
 679     }
 680
 681     public Gtk.TreePath? get_path(Gtk.TreeIter iter)
 682     {
 683         var path = new Gtk.TreePath();
 684         for (var d = get_directory(iter); d != root; d = d.parent)
 685             path.prepend_index((int)d.index);
 686         return path;
 687     }
 688
 689     public void get_value(Gtk.TreeIter iter, int column, out Value value)
 690     {
 691         if (column == 0)
 692             value = get_directory(iter);
 693         else
 694             value = get_directory(iter).name;
 695     }
 696
 697     public bool iter_next(ref Gtk.TreeIter iter)
 698     {
 699         var directory = get_directory(iter);
 700         if (directory.index >= directory.parent.children.length() - 1)
 701             return false;
 702         set_iter(ref iter, directory.parent.children.nth_data(directory.index+1));
 703
 704         return true;
 705     }
 706
 707     public bool iter_children(out Gtk.TreeIter iter, Gtk.TreeIter? parent)
 708     {
 709         iter = Gtk.TreeIter();
 710
 711         var directory = get_directory(parent);
 712         if (directory.children.length() == 0)
 713             return false;
 714         set_iter(ref iter, directory.children.nth_data(0));
 715
 716         return true;
 717     }
 718
 719     public bool iter_has_child(Gtk.TreeIter iter)
 720     {
 721         return get_directory(iter).children.length() > 0;
 722     }
 723
 724     public int iter_n_children(Gtk.TreeIter? iter)
 725     {
 726         return (int) get_directory(iter).children.length();
 727     }
 728
 729     public bool iter_nth_child(out Gtk.TreeIter iter, Gtk.TreeIter? parent, int n)
 730     {
 731         iter = Gtk.TreeIter();
 732
 733         var directory = get_directory(parent);
 734         if (n >= directory.children.length())
 735             return false;
 736         set_iter(ref iter, directory.children.nth_data(n));
 737
 738         return true;
 739     }
 740
 741     public bool iter_parent(out Gtk.TreeIter iter, Gtk.TreeIter child)
 742     {
 743         iter = Gtk.TreeIter();
 744
 745         var directory = get_directory(child);
 746         if (directory.parent == root)
 747             return false;
 748
 749         set_iter(ref iter, directory.parent);
 750
 751         return true;
 752     }
 753
 754     public void ref_node(Gtk.TreeIter iter)
 755     {
 756         get_directory(iter).ref();
 757     }
 758
 759     public void unref_node(Gtk.TreeIter iter)
 760     {
 761         get_directory(iter).unref();
 762     }
 763 }