This modules provides a monad that encapsulates the information in an event.

The events a widget can receive are defined in Graphics.UI.Gtk.Abstract.Widget. Every event carries additional information which is accessible through functions in the EventM monad. For instance, every event is associated with a Graphics.UI.Gtk.Gdk.DrawWindow.DrawWindow which is accessed using the eventWindow accessor function. Other information is only available in one specific event. For example, the area that has to be redrawn, accessed by eventArea is only available in the Graphics.UI.Gtk.Abstract.Widget.exposeEvent. Indeed, you can only call eventArea if the first type parameter of EventM is the phantom type EExpose. (A phantom type is a type for which no values exist and which is only used to enforce certain constraints on the usage of functions such as eventArea.) Some information is available in several but not all events. In order to express these constraints the module defines type classes whose names start with Has... but which are not exported, implying that no new instance can be created. (They could be called phantom type classes.) For instance, the mouse pointer coordinates can be retrieved using the function eventCoordinates which requires that the first type parameter of EventM is in the class HasCoordinates. The module supplies instance of class HasCoordinates for the types EButton, ECrossing, EMotion and EScroll. Thus for all events that require an EventM action with one of the types above, the accessor function eventCoordinates may be used.

Note that an event handler must always returns True if the event was handled or False if the event should be dealt with by another event handler. For instance, a handler for a key press should return False if the pressed key is not one of those that the widget reacts to. In this case the event is passed to the parent widgets. This ensures that pressing, say, Alt-F opens the file menu even if the current input focus is in a text entry widget. In order to facilitate writing handlers that may abort handling an event, this module provides the function tryEvent. This function catches pattern match exceptions and returns False. If the signal successfully runs to its end, it returns True. A typical use is as follows:

 widget `on` keyPressEvent $ tryEvent $ do
   [Control] <- eventModifier
   "Return" <- eventKeyName
   liftIO $ putStrLn "Ctrl-Return pressed"

The rationale is that the action will throw an exception if the two event functions eventModifier and eventKeyName return something else than what is stated in the pattern. When no exception is thrown, execution continues to the last statement where the event is processed, here we merely print a message. Note that the return value of this statement must be () since tryEvent always assumes that the function handeled the event if no exception is thrown. A handler wrapped by tryEvent can also indicate that it cannot handle the given event by calling stopEvent.

Finally, not that the EventM monad wraps the IO monad. As such you can (and usually have to) use liftIO to execute IO functions.