bludgeon/Action.cs

   1
   2 using System;
   3 using System.Collections;
   4
   5 using Beagle.Util;
   6
   7 namespace Bludgeon {
   8
   9         public class Action {
  10
  11                 // Note that the way we manipulate Action.Count and closure.Id
  12                 // is violently non-threadsafe.  Fixing this should be pretty
  13                 // easy, and is left as an exercise to the reader.
  14
  15                 public interface Handle { }
  16
  17                 // Should be private, but that is just too messy
  18                 // for this code.
  19                 static public int Count = 0;
  20
  21                 private class Closure : Handle {
  22                         public uint Id;
  23
  24                         private GLib.TimeoutHandler timeout_handler;
  25                         private GLib.IdleHandler idle_handler;
  26
  27                         public Closure (GLib.TimeoutHandler timeout_handler)
  28                         {
  29                                 this.timeout_handler = timeout_handler;
  30                                 ++Count;
  31                         }
  32
  33                         public Closure (GLib.IdleHandler idle_handler)
  34                         {
  35                                 this.idle_handler = idle_handler;
  36                                 ++Count;
  37                         }
  38
  39                         public bool Handler ()
  40                         {
  41                                 if (Id == 0)
  42                                         return false;
  43
  44                                 bool rv = false;
  45                                 if (timeout_handler != null)
  46                                         rv = timeout_handler ();
  47                                 else if (idle_handler != null)
  48                                         rv = idle_handler ();
  49                                 if (! rv) {
  50                                         Id = 0;
  51                                         --Count;
  52                                 }
  53                                 if (Count == 0)
  54                                         BludgeonMain.Shutdown ();
  55
  56                                 return rv;
  57                         }
  58                 }
  59
  60                 // RENAMEME: It is linguistically awkward that we pass in
  61                 // "handlers", and get back "handles".
  62                 static public Handle Add (GLib.IdleHandler idle_handler)
  63                 {
  64                         Closure c;
  65                         c = new Closure (idle_handler);
  66                         c.Id = GLib.Idle.Add (new GLib.IdleHandler (c.Handler));
  67                         return c;
  68                 }
  69
  70                 static public Handle Add (uint t, GLib.TimeoutHandler timeout_handler)
  71                 {
  72                         Closure c;
  73                         c = new Closure (timeout_handler);
  74                         c.Id = GLib.Timeout.Add (t, new GLib.TimeoutHandler (c.Handler));
  75                         return c;
  76                 }
  77
  78                 static public void Cancel (Handle h)
  79                 {
  80                         Closure c = (Closure) h;
  81
  82                         if (c.Id != 0) {
  83                                 GLib.Source.Remove (c.Id);
  84                                 --Count;
  85                         }
  86                         if (Count == 0) {
  87                                 // We add an empty idle task, which will increment
  88                                 // the count up back above 0.  This keeps us from
  89                                 // shutting down the system until the next time control
  90                                 // is passed to the main loop.
  91                                 Add (null);
  92                         }
  93                 }
  94         }
  95 }