editor/dconf-view.vala

   1 private class KeyValueRenderer: Gtk.CellRenderer
   2 {
   3     private DConfKeyView view;
   4     private Gtk.CellRendererText text_renderer;
   5     private Gtk.CellRendererSpin spin_renderer;
   6     private Gtk.CellRendererToggle toggle_renderer;
   7     private Gtk.CellRendererCombo combo_renderer;
   8
   9     private Key _key;
  10     public Key key
  11     {
  12         get { return _key; }
  13         set
  14         {
  15             _key = value;
  16
  17             if (key.has_schema && key.schema.choices != null)
  18             {
  19                 combo_renderer.text = key.value.print(false);
  20                 var model = new Gtk.ListStore(2, typeof(string), typeof(string));
  21                 foreach (var choice in key.schema.choices)
  22                 {
  23                     Gtk.TreeIter iter;
  24                     model.append(out iter);
  25                     model.set(iter, 0, choice.name, 1, choice.value.print(false), -1);
  26                 }
  27                 combo_renderer.model = model;
  28                 mode = Gtk.CellRendererMode.EDITABLE;
  29                 return;
  30             }
  31
  32             switch (key.type_string)
  33             {
  34             case "<enum>":
  35                 combo_renderer.text = key.value.get_string();
  36                 combo_renderer.model = new EnumModel(key.schema.schema.list.enums.lookup(key.schema.enum_name));
  37                 mode = Gtk.CellRendererMode.EDITABLE;
  38                 break;
  39             case "b":
  40                 toggle_renderer.active = key.value.get_boolean();
  41                 mode = Gtk.CellRendererMode.ACTIVATABLE;
  42                 break;
  43             case "s":
  44                 text_renderer.text = key.value.get_string();
  45                 mode = Gtk.CellRendererMode.EDITABLE;
  46                 break;
  47             case "y":
  48             case "n":
  49             case "q":
  50             case "i":
  51             case "u":
  52             case "x":
  53             case "t":
  54             case "d":
  55                 spin_renderer.text = key.value.print(false);
  56                 var v = get_variant_as_double(key.value);
  57                 double min = 0.0, max = 0.0;
  58                 if (key.has_schema && key.schema.range != null)
  59                 {
  60                     min = get_variant_as_double(key.schema.range.min);
  61                     max = get_variant_as_double(key.schema.range.max);
  62                 }
  63                 else
  64                 {
  65                     min = get_variant_as_double(key.get_min());
  66                     max = get_variant_as_double(key.get_max());
  67                 }
  68                 spin_renderer.adjustment = new Gtk.Adjustment(v, min, max, 1, 0, 0);
  69                 spin_renderer.digits = 0;
  70                 mode = Gtk.CellRendererMode.EDITABLE;
  71                 break;
  72             default:
  73                 text_renderer.text = key.value.print(false);
  74                 mode = Gtk.CellRendererMode.EDITABLE;
  75                 break;
  76             }
  77         }
  78     }
  79
  80     private static double get_variant_as_double(Variant value)
  81     {
  82         if (value == null)
  83             return 0.0;
  84
  85         switch (value.classify ())
  86         {
  87         case Variant.Class.BYTE:
  88             return (double)value.get_byte();
  89         case Variant.Class.INT16:
  90             return (double)value.get_int16();
  91         case Variant.Class.UINT16:
  92             return (double)value.get_uint16();
  93         case Variant.Class.INT32:
  94             return (double)value.get_int32();
  95         case Variant.Class.UINT32:
  96             return (double)value.get_uint32();
  97         case Variant.Class.INT64:
  98             return (double)value.get_int64();
  99         case Variant.Class.UINT64:
 100             return (double)value.get_uint64();
 101         case Variant.Class.DOUBLE:
 102             return value.get_double();
 103         default:
 104             return 0.0;
 105         }
 106     }
 107
 108     public KeyValueRenderer(DConfKeyView view)
 109     {
 110         this.view = view;
 111
 112         text_renderer = new Gtk.CellRendererText();
 113         text_renderer.editable = true;
 114         text_renderer.edited.connect(text_edited_cb);
 115
 116         spin_renderer = new Gtk.CellRendererSpin();
 117         spin_renderer.editable = true;
 118         spin_renderer.edited.connect(spin_edited_cb);
 119
 120         toggle_renderer = new Gtk.CellRendererToggle();
 121         toggle_renderer.xalign = 0f;
 122         toggle_renderer.activatable = true;
 123         toggle_renderer.toggled.connect(toggle_cb);
 124
 125         combo_renderer = new Gtk.CellRendererCombo();
 126         combo_renderer.has_entry = false;
 127         combo_renderer.text_column = 0;
 128         combo_renderer.editable = true;
 129         combo_renderer.edited.connect(text_edited_cb);
 130     }
 131
 132     private Gtk.CellRenderer renderer
 133     {
 134         set {}
 135         get
 136         {
 137             if (key.has_schema && key.schema.choices != null)
 138                 return combo_renderer;
 139
 140             switch (key.type_string)
 141             {
 142             case "<enum>":
 143                 return combo_renderer;
 144             case "b":
 145                 return toggle_renderer;
 146             case "y":
 147             case "n":
 148             case "q":
 149             case "i":
 150             case "u":
 151             case "x":
 152             case "t":
 153             case "d":
 154                 return spin_renderer;
 155             default:
 156             case "s":
 157                 return text_renderer;
 158             }
 159         }
 160     }
 161
 162     public override void get_size(Gtk.Widget     widget,
 163                                   Gdk.Rectangle? cell_area,
 164                                   out int        x_offset,
 165                                   out int        y_offset,
 166                                   out int        width,
 167                                   out int        height)
 168     {
 169         renderer.get_size(widget, cell_area, out x_offset, out y_offset, out width, out height);
 170     }
 171
 172     public override void get_preferred_width(Gtk.Widget widget,
 173                                              out int    minimum_size,
 174                                              out int    natural_size)
 175     {
 176         renderer.get_preferred_width(widget, out minimum_size, out natural_size);
 177     }
 178
 179     public override void get_preferred_height_for_width(Gtk.Widget widget,
 180                                                         int        width,
 181                                                         out int    minimum_height,
 182                                                         out int    natural_height)
 183     {
 184         renderer.get_preferred_height_for_width(widget, width, out minimum_height, out natural_height);
 185     }
 186
 187     public override void get_preferred_height(Gtk.Widget widget,
 188                                               out int    minimum_size,
 189                                               out int    natural_size)
 190     {
 191         renderer.get_preferred_height(widget, out minimum_size, out natural_size);
 192     }
 193
 194     public override void get_preferred_width_for_height(Gtk.Widget widget,
 195                                                         int        height,
 196                                                         out int    minimum_width,
 197                                                         out int    natural_width)
 198     {
 199         renderer.get_preferred_width_for_height(widget, height, out minimum_width, out natural_width);
 200     }
 201
 202     public override void render(Cairo.Context context,
 203                                 Gtk.Widget    widget,
 204                                 Gdk.Rectangle background_area,
 205                                 Gdk.Rectangle cell_area,
 206                                 Gtk.CellRendererState flags)
 207     {
 208         renderer.render(context, widget, background_area, cell_area, flags);
 209     }
 210
 211     public override bool activate(Gdk.Event event,
 212                                   Gtk.Widget widget,
 213                                   string path,
 214                                   Gdk.Rectangle background_area,
 215                                   Gdk.Rectangle cell_area,
 216                                   Gtk.CellRendererState flags)
 217     {
 218         return renderer.activate(event, widget, path, background_area, cell_area, flags);
 219     }
 220
 221     public override unowned Gtk.CellEditable start_editing(Gdk.Event event,
 222                                                            Gtk.Widget widget,
 223                                                            string path,
 224                                                            Gdk.Rectangle background_area,
 225                                                            Gdk.Rectangle cell_area,
 226                                                            Gtk.CellRendererState flags)
 227     {
 228         return renderer.start_editing(event, widget, path, background_area, cell_area, flags);
 229     }
 230
 231     private Key get_key_from_path(string path)
 232     {
 233         Gtk.TreeIter iter;
 234         view.model.get_iter_from_string(out iter, path);
 235
 236         Key key;
 237         view.model.get(iter, 0, out key, -1);
 238
 239         return key;
 240     }
 241
 242     private void toggle_cb(Gtk.CellRendererToggle renderer, string path)
 243     {
 244         var key = get_key_from_path(path);
 245         key.value = new Variant.boolean(!key.value.get_boolean());
 246     }
 247
 248     private void text_edited_cb(Gtk.CellRendererText renderer, string path, string text)
 249     {
 250         var key = get_key_from_path(path);
 251         if (key.type_string == "s" || key.type_string == "<enum>")
 252         {
 253             key.value = new Variant.string(text);
 254         }
 255         else
 256         {
 257             try
 258             {
 259                 var value = Variant.parse(new VariantType(key.type_string), text);
 260                 key.value = value;
 261             }
 262             catch (VariantParseError e)
 263             {
 264                 var dialog = new Gtk.MessageDialog(null, Gtk.DialogFlags.MODAL, Gtk.MessageType.WARNING, Gtk.ButtonsType.OK, _("Error setting value: %s"), e.message);
 265                 dialog.run();
 266                 dialog.destroy();
 267             }
 268         }
 269     }
 270
 271     private void spin_edited_cb(Gtk.CellRendererText renderer, string path, string text)
 272     {
 273         var key = get_key_from_path(path);
 274         switch (key.type_string)
 275         {
 276         case "y":
 277             key.value = new Variant.byte((uchar)int.parse(text));
 278             break;
 279         case "n":
 280             key.value = new Variant.int16((int16)int.parse(text));
 281             break;
 282         case "q":
 283             key.value = new Variant.uint16((uint16)int.parse(text));
 284             break;
 285         case "i":
 286             key.value = new Variant.int32(int.parse(text));
 287             break;
 288         case "u":
 289             key.value = new Variant.uint32(int.parse(text));
 290             break;
 291         case "x":
 292             key.value = new Variant.int64(int.parse(text));
 293             break;
 294         case "t":
 295             key.value = new Variant.uint64(int.parse(text));
 296             break;
 297         case "d":
 298             key.value = new Variant.double(double.parse(text));
 299             break;
 300         }
 301     }
 302 }
 303
 304 public class DConfDirView : Gtk.TreeView
 305 {
 306     public DConfDirView()
 307     {
 308         set_headers_visible(false);
 309         insert_column_with_attributes(-1, "Key", new Gtk.CellRendererText(), "text", 1, null);
 310     }
 311 }
 312
 313 public class DConfKeyView : Gtk.TreeView
 314 {
 315     public DConfKeyView()
 316     {
 317                 /* Translators: this is the column header label in the main view */
 318         var column = new Gtk.TreeViewColumn.with_attributes(_("Name"), new Gtk.CellRendererText(), "text", 1, "weight", 4, null);
 319         /*column.set_sort_column_id(1);*/
 320         append_column(column);
 321                 /* Translators: this is the column header label in the main view */
 322         insert_column_with_attributes(-1, _("Value"), new KeyValueRenderer(this), "key", 0, null);
 323     }
 324 }