Util/XKeybinder.cs

   1
   2 using System;
   3 using System.Collections;
   4 using System.Runtime.InteropServices;
   5
   6 namespace Beagle.Util
   7 {
   8         public class XKeybinder
   9         {
  10                 [DllImport("libbeagleuiglue")]
  11                 static extern void tomboy_keybinder_init ();
  12
  13                 [DllImport("libbeagleuiglue")]
  14                 static extern void tomboy_keybinder_bind (string keystring,
  15                                                           BindkeyHandler handler);
  16
  17                 [DllImport("libbeagleuiglue")]
  18                 static extern void tomboy_keybinder_unbind (string keystring,
  19                                                             BindkeyHandler handler);
  20
  21                 public delegate void BindkeyHandler (string key, IntPtr user_data);
  22
  23                 ArrayList      bindings;
  24                 BindkeyHandler key_handler;
  25
  26                 struct Binding {
  27                         internal string       keystring;
  28                         internal EventHandler handler;
  29                 }
  30
  31                 public XKeybinder ()
  32                         : base ()
  33                 {
  34                         bindings = new ArrayList ();
  35                         key_handler = new BindkeyHandler (KeybindingPressed);
  36
  37                         tomboy_keybinder_init ();
  38                 }
  39
  40                 void KeybindingPressed (string keystring, IntPtr user_data)
  41                 {
  42                         foreach (Binding bind in bindings) {
  43                                 if (bind.keystring == keystring) {
  44                                         bind.handler (this, new EventArgs ());
  45                                 }
  46                         }
  47                 }
  48
  49                 public void Bind (string       keystring,
  50                                   EventHandler handler)
  51                 {
  52                         Binding bind = new Binding ();
  53                         bind.keystring = keystring;
  54                         bind.handler = handler;
  55                         bindings.Add (bind);
  56
  57                         tomboy_keybinder_bind (bind.keystring, key_handler);
  58                 }
  59
  60                 public void Unbind (string keystring)
  61                 {
  62                         foreach (Binding bind in bindings) {
  63                                 if (bind.keystring == keystring) {
  64                                         tomboy_keybinder_unbind (bind.keystring,
  65                                                                  key_handler);
  66
  67                                         bindings.Remove (bind);
  68                                         break;
  69                                 }
  70                         }
  71                 }
  72
  73                 public virtual void UnbindAll ()
  74                 {
  75                         foreach (Binding bind in bindings) {
  76                                 tomboy_keybinder_unbind (bind.keystring, key_handler);
  77                         }
  78
  79                         bindings.Clear ();
  80                 }
  81         }
  82
  83         public class GConfXKeybinder : XKeybinder
  84         {
  85                 GConf.Client client;
  86                 ArrayList bindings;
  87
  88                 public GConfXKeybinder ()
  89                 {
  90                         client = new GConf.Client ();
  91                         bindings = new ArrayList ();
  92                 }
  93
  94                 public void Bind (string       gconf_path,
  95                                   string       default_binding,
  96                                   EventHandler handler)
  97                 {
  98                         try {
  99                                 Binding binding = new Binding (gconf_path,
 100                                                                default_binding,
 101                                                                handler,
 102                                                                this);
 103                                 bindings.Add (binding);
 104                         } catch (Exception e) {
 105                                 Logger.Log.Error ("Error Adding global keybinding:");
 106                                 Logger.Log.Error (e);
 107                         }
 108                 }
 109
 110                 public override void UnbindAll ()
 111                 {
 112                         try {
 113                                 bindings.Clear ();
 114                                 base.UnbindAll ();
 115                         } catch (Exception e) {
 116                                 Logger.Log.Error ("Error Removing global keybinding:");
 117                                 Logger.Log.Error (e);
 118                         }
 119                 }
 120
 121                 class Binding
 122                 {
 123                         public string   gconf_path;
 124                         public string   key_sequence;
 125                         EventHandler    handler;
 126                         GConfXKeybinder parent;
 127
 128                         public Binding (string          gconf_path,
 129                                         string          default_binding,
 130                                         EventHandler    handler,
 131                                         GConfXKeybinder parent)
 132                         {
 133                                 this.gconf_path = gconf_path;
 134                                 this.key_sequence = default_binding;
 135                                 this.handler = handler;
 136                                 this.parent = parent;
 137
 138                                 try {
 139                                         key_sequence = (string) parent.client.Get (gconf_path);
 140                                 } catch (Exception e) {
 141                                         Logger.Log.Warn ("GConf key '{0}' does not exist, using default.",
 142                                                          gconf_path);
 143                                 }
 144
 145                                 SetBinding ();
 146
 147                                 parent.client.AddNotify (
 148                                         gconf_path,
 149                                         new GConf.NotifyEventHandler (BindingChanged));
 150                         }
 151
 152                         void BindingChanged (object sender, GConf.NotifyEventArgs args)
 153                         {
 154                                 if (args.Key == gconf_path) {
 155                                         Logger.Log.Debug ("Binding for '{0}' changed to '{1}'!",
 156                                                           gconf_path,
 157                                                           args.Value);
 158
 159                                         UnsetBinding ();
 160
 161                                         key_sequence = (string) args.Value;
 162                                         SetBinding ();
 163                                 }
 164                         }
 165
 166                         public void SetBinding ()
 167                         {
 168                                 if (key_sequence == null ||
 169                                     key_sequence == String.Empty ||
 170                                     key_sequence == "disabled")
 171                                         return;
 172
 173                                 Logger.Log.Debug ("Binding key '{0}' for '{1}'",
 174                                                   key_sequence,
 175                                                   gconf_path);
 176
 177                                 parent.Bind (key_sequence, handler);
 178                         }
 179
 180                         public void UnsetBinding ()
 181                         {
 182                                 if (key_sequence == null)
 183                                         return;
 184
 185                                 Logger.Log.Debug ("Unbinding key '{0}' for '{1}'",
 186                                                   key_sequence,
 187                                                   gconf_path);
 188
 189                                 parent.Unbind (key_sequence);
 190                         }
 191                 }
 192         }
 193 }