public MainEvent()
        {
            InitializeComponent();

            List<string> hours = new List<string>();
            for (int i = 0; i < 24; i++)
            {
                hours.Add(i.ToString("00"));
            }
            cbFromHour.ItemsSource = hours;
            cbFromHour.SelectedIndex = 0;

            cbUntilHour.ItemsSource = hours;
            cbUntilHour.SelectedIndex = 0;

            List<string> minutes = new List<string>();
            for (int i = 0; i < 12; i++)
            {
                minutes.Add((i * 5).ToString("00"));
            }
            cbFromMin.ItemsSource = minutes;
            cbFromMin.SelectedIndex = 0;

            cbUntilMin.ItemsSource = minutes;
            cbUntilMin.SelectedIndex = 0;

            dpFromDate.SelectedDate = DateTime.Now.Date;
            dpUntilDate.SelectedDate = DateTime.Now.AddHours(1).Date;

            mEventTypes = new EventTypes();
            cbEventTypes.ItemsSource = mEventTypes;
        }

 public static void RaiseEventMessage(object sender, string Message, EventTypes type)
 {
     if (EventMessage != null)
     {
         EventMessage(sender, Message, type);
     }
 }

 public IOWatcher(IntPtr fd, EventTypes types, Loop loop, Action<IOWatcher, EventTypes> callback)
     : base(loop)
 {
     this.fd = fd;
     this.callback = callback;
     watcher_ptr = manos_io_watcher_create (fd.ToInt32 (), types, watcherCallback, GCHandle.ToIntPtr (gc_handle));
 }

 //unsubscribe this event from event matching eventType
 public void Unsubscribe(IObserver listener, EventTypes eventType)
 {
   if (listenerTable.Keys.Contains(eventType))
   {
     listenerTable[eventType].Remove(listener);
   }
 }

 public int AttachEvent(VlcEventManagerInstance eventManagerInstance, EventTypes eventType, EventCallback callback)
 {
     if (eventManagerInstance == IntPtr.Zero)
         throw new ArgumentException("Event manager instance is not initialized.");
     if (callback == null)
         throw new ArgumentException("Callback for event is not initialized.");
     return GetInteropDelegate<AttachEvent>().Invoke(eventManagerInstance, eventType, callback, IntPtr.Zero);
 }

 /*
   Subscribers/listeners register with the event system
 */
 public void Subscribe(IObserver listener, EventTypes eventType)
 {
   if (!listenerTable.Keys.Contains(eventType))
   {
     listenerTable[eventType] = new HashSet<IObserver>();
   }
   listenerTable[eventType].Add(listener);
 }

        public UniEvent(EventTypes type)
        {
            Type = type;
            Actions = new List<UniAction>();

            Options = new JSONObject();
            Options.AddField("type", Type.ToString());
        }

        public string GetEventTypeName(EventTypes eventType)
        {
#if !NET20
            return GetInteropDelegate<GetEventTypeName>().Invoke(eventType).ToStringAnsi();
#else
            return IntPtrExtensions.ToStringAnsi(GetInteropDelegate<GetEventTypeName>().Invoke(eventType));
#endif
        }

        public IOWatcher(IntPtr fd, EventTypes types, LibEvLoop loop, IOWatcherCallback callback)
            : base(loop)
        {
            this.fd = fd;
            this.callback = callback;

            watcher_ptr = manos_io_watcher_create(fd.ToInt32(), types | EventTypes.EV__IOFDSET,
                watcherCallback, GCHandle.ToIntPtr(gc_handle));
        }

        private static void StaticCallback(IntPtr loop, IntPtr watcher, EventTypes revents)
        {
            UnmanagedPrepareWatcher iow = (UnmanagedPrepareWatcher) Marshal.PtrToStructure (watcher, typeof (UnmanagedPrepareWatcher));

            GCHandle gchandle = GCHandle.FromIntPtr (iow.data);
            PrepareWatcher w = (PrepareWatcher) gchandle.Target;

            w.callback (w.Loop, w, revents);
        }

 private static void StaticCallback(IntPtr data, EventTypes revents)
 {
     try {
         var handle = GCHandle.FromIntPtr (data);
         var watcher = (IOWatcher) handle.Target;
         watcher.callback (watcher, revents);
     } catch (Exception e) {
         Console.Error.WriteLine ("Error handling IO readyness event: {0}", e.Message);
         Console.Error.WriteLine (e.StackTrace);
     }
 }

 static void StaticCallback(IntPtr data, EventTypes revents)
 {
     Error.Log.Call<System.Exception>(() =>
     {
         var handle = GCHandle.FromIntPtr(data);
         var watcher = (IOWatcher)handle.Target;
         watcher.callback(watcher, revents);
     }, e =>
     {
         Console.Error.WriteLine("Error handling IO readyness event: {0}", e.Message);
         Console.Error.WriteLine(e.StackTrace);
     });
 }

        // all event handler attribute accessors should eventually call these
        public static string GetEventHandlerAttr(mdr.DObject obj, EventTypes type, string name)
        {
#if ENABLE_RR
            if (RecordReplayManager.Instance != null && RecordReplayManager.Instance.RecordEnabled)
            {
                mwr.RecordReplayManager.Instance.Record("Element", null, "GetEventHandlerAttr", false, obj, type, name);
            }
#endif
            var targetElement = obj.FirstInPrototypeChainAs<HTMLElement>();
            var s = targetElement.PrimGetEventHandlerAttr(type);
            Debug.WriteLine("GetEventHandlerAttr({0}) = '{1}'", name, s);
            return s;
        }

    public bool EventIsActive(Bands b, int c, EventTypes e)
    {
        if (e == EventTypes.BEAT)
        {
            return bandData[bandOffsets[c, (int) b]].Beat;
        }
        else if (e == EventTypes.VIBRATION)
        {
            return bandData[bandOffsets[c, (int) b]].Vibration;
        }

        return false;
    }

        /// <summary>
        /// Gets event list models by event type
        /// </summary>
        /// <param name="eventType">Event type to get by</param>
        /// <returns>An event list model</returns>
        private EventListModel FetchFromRedis(EventTypes eventType)
        {
            try
            {
                var redisClient = new RedisClient("localhost");
                var eventClient = redisClient.As<EventListModel>();

                return eventClient.GetById((int)eventType);
            }
            catch (Exception)
            {
                return new EventListModel();
            }
        }

        public IOWatcher(IntPtr fd, EventTypes types, Loop loop, IOWatcherCallback callback)
            : base(loop)
        {
            this.fd = fd;
            this.callback = callback;

            unmanaged_watcher = new UnmanagedIOWatcher ();

            unmanaged_watcher.fd = fd.ToInt32 ();
            unmanaged_watcher.events = types | EventTypes.EV__IOFDSET;

            unmanaged_watcher.callback = CallbackFunctionPtr;

            InitializeUnmanagedWatcher (unmanaged_watcher);
        }

        public void LogEvent(string message, EventTypes eType)
        {
            log4net.Config.XmlConfigurator.Configure(GetTestConfig());

            if (eType==EventTypes.Info)
            {
                Log.Info(message);
            }else if (eType==EventTypes.Warn)
            {
                Log.Warn(message);
            }else if (eType==EventTypes.Error)
            {
                Log.Error(message);
            }
            else if (eType == EventTypes.Fatal)
            {
                Log.Fatal(message);
            }
            else
            { Log.Info(message); }
        }

 public EventHandlerProperty(EventTypes eventType)
     : base()
 {
     EventType = eventType;
     TargetValueType = mdr.ValueTypes.Function;
     //We should static or constants in the following methods to avoid expensive delegates!
     OnGetDValue = (mdr.DObject This, ref mdr.DValue v) =>
     {
         var eventListeners = GetEventListeners(This, eventType);
         var idlListener = eventListeners.IdlListener;
         if (idlListener != null)
             v.Set(idlListener);
         else
             v.Set(mdr.Runtime.Instance.DefaultDNull);
     };
     OnSetDValue = (mdr.DObject This, ref mdr.DValue v) =>
     {
         var eventListeners = GetEventListeners(This, eventType);
         Debug.WriteLine("Setting the IDL listener for event type " + eventType.ToString() + " : type " + v.ValueType.ToString());
         var idlListener = (v.ValueType == mdr.ValueTypes.Function) ? v.AsDFunction() : null;
         eventListeners.IdlListener = idlListener;
     };
 }

        public UserControl(EventTypes eventType, int streamId = 1, int bufferlength = 1000, int pingTime = 0)
            : base(4)
        {
            var memory = new MemoryStream();
            var writer = new EndianBinaryWriter(EndianBitConverter.Big, memory);
            writer.Write((ushort) eventType);

            switch (eventType)
            {
                case EventTypes.StreamBegin:
                    writer.Write(streamId);
                    break;
                case EventTypes.StreamEOF:
                    writer.Write(streamId);
                    break;
                case EventTypes.StreamDry:
                    writer.Write(streamId);
                    break;
                case EventTypes.SetBufferLength:
                    writer.Write(streamId);
                    writer.Write(bufferlength);
                    break;
                case EventTypes.StreamIsRecorded:
                    writer.Write(streamId);
                    break;
                case EventTypes.PingRequest:
                    writer.Write(pingTime);
                    break;
                case EventTypes.PingResponse:
                    writer.Write(pingTime);
                    break;
                default:
                    break;
            }
            Data = memory.ToArray();
        }

 public EventPacket(EventTypes type, byte[] data)
 {
   Type = type;
   Data = data;
 }