Add API entries for UIEvents

src/DOM/Event/CompositionEvent.js

@@ -0,0 +1,5 @@
+"use strict";
+
+exports.data_ = function (e) {
+  return e.data;
+};

src/DOM/Event/CompositionEvent.purs

@@ -0,0 +1,15 @@
+module DOM.Event.CompositionEvent (
+    module T,
+    eventToCompositionEvent,
+    data_
+    ) where
+
+import Prelude
+import Data.Foreign (F, toForeign)
+import DOM.Event.Types (CompositionEvent, Event, readCompositionEvent)
+import DOM.Event.Types (CompositionEvent, compositionEventToEvent, readCompositionEvent) as T
+
+eventToCompositionEvent :: Event -> F CompositionEvent
+eventToCompositionEvent = readCompositionEvent <<< toForeign
+
+foreign import data_ :: CompositionEvent -> String

src/DOM/Event/FocusEvent.js

@@ -0,0 +1,5 @@
+"use strict";
+
+exports.relatedTargetNullable = function (e) {
+  return e.relatedTarget;
+};

src/DOM/Event/FocusEvent.purs

@@ -0,0 +1,20 @@
+module DOM.Event.FocusEvent
+  ( module T
+  , eventToFocusEvent
+  , relatedTarget
+  ) where
+
+import Prelude
+import Data.Foreign (F, toForeign)
+import Data.Maybe (Maybe)
+import Data.Nullable (Nullable, toMaybe)
+import DOM.Event.Types (Event, EventTarget, FocusEvent, readFocusEvent)
+import DOM.Event.Types (FocusEvent, focusEventToEvent, readFocusEvent) as T
+
+eventToFocusEvent :: Event -> F FocusEvent
+eventToFocusEvent = readFocusEvent <<< toForeign
+
+foreign import relatedTargetNullable :: FocusEvent -> Nullable EventTarget
+
+relatedTarget :: FocusEvent -> Maybe EventTarget
+relatedTarget = toMaybe <$> relatedTargetNullable

src/DOM/Event/KeyboardEvent.js

@@ -0,0 +1,45 @@
+"use strict";
+
+exports.key = function (e) {
+  return e.key;
+};
+
+exports.code = function (e) {
+  return e.code;
+};
+
+exports.locationIndex = function (e) {
+  return e.location;
+};
+
+exports.ctrlKey = function (e) {
+  return e.ctrlKey;
+};
+
+exports.shiftKey = function (e) {
+  return e.shiftKey;
+};
+
+exports.altKey = function (e) {
+  return e.altKey;
+};
+
+exports.metaKey = function (e) {
+  return e.metaKey;
+};
+
+exports.repeat = function (e) {
+  return e.repeat;
+};
+
+exports.isComposing = function (e) {
+  return e.isComposing;
+};
+
+exports.getModifierState = function (s) {
+  return function (e) {
+    return function () {
+      return e.getModifierState(s);
+    };
+  };
+};

src/DOM/Event/KeyboardEvent.purs

@@ -0,0 +1,96 @@
+module DOM.Event.KeyboardEvent
+  ( module T
+  , eventToKeyboardEvent
+  , key
+  , code
+  , locationIndex
+  , location
+  , KeyLocation(..)
+  , toEnumKeyLocation
+  , fromEnumKeyLocation
+  , ctrlKey
+  , shiftKey
+  , altKey
+  , metaKey
+  , repeat
+  , isComposing
+  , getModifierState
+  ) where
+
+import Prelude
+import Control.Monad.Eff (Eff)
+import Data.Enum (class BoundedEnum, class Enum, Cardinality(..), defaultPred, defaultSucc, toEnum)
+import Data.Foreign (F, toForeign)
+import Data.Maybe (Maybe(..), fromJust)
+import DOM (DOM)
+import DOM.Event.Types (Event, KeyboardEvent, readKeyboardEvent)
+import DOM.Event.Types (KeyboardEvent, keyboardEventToEvent, readKeyboardEvent) as T
+
+eventToKeyboardEvent :: Event -> F KeyboardEvent
+eventToKeyboardEvent = readKeyboardEvent <<< toForeign
+
+foreign import key :: KeyboardEvent -> String
+
+foreign import code :: KeyboardEvent -> String
+
+foreign import locationIndex :: KeyboardEvent -> Int
+
+location :: Partial => KeyboardEvent -> KeyLocation
+location = fromJust <<< toEnum <<< locationIndex
+
+data KeyLocation
+  = Standard
+  | Left
+  | Right
+  | Numpad
+
+derive instance eqKeyLocation :: Eq KeyLocation
+derive instance ordKeyLocation :: Ord KeyLocation
+
+instance boundedKeyLocation :: Bounded KeyLocation where
+  bottom = Standard
+  top = Numpad
+
+instance enumKeyLocation :: Enum KeyLocation where
+  succ = defaultSucc toEnumKeyLocation fromEnumKeyLocation
+  pred = defaultPred toEnumKeyLocation fromEnumKeyLocation
+
+instance boundedEnumKeyLocation :: BoundedEnum KeyLocation where
+  cardinality = Cardinality 4
+  toEnum = toEnumKeyLocation
+  fromEnum = fromEnumKeyLocation
+
+toEnumKeyLocation :: Int -> Maybe KeyLocation
+toEnumKeyLocation =
+  case _ of
+    0 -> Just Standard
+    1 -> Just Left
+    2 -> Just Right
+    3 -> Just Numpad
+    _ -> Nothing
+
+fromEnumKeyLocation :: KeyLocation -> Int
+fromEnumKeyLocation =
+  case _ of
+    Standard -> 0
+    Left -> 1
+    Right -> 2
+    Numpad -> 3
+
+foreign import ctrlKey :: KeyboardEvent -> Boolean
+
+foreign import shiftKey :: KeyboardEvent -> Boolean
+
+foreign import altKey :: KeyboardEvent -> Boolean
+
+foreign import metaKey :: KeyboardEvent -> Boolean
+
+foreign import repeat :: KeyboardEvent -> Boolean
+
+foreign import isComposing :: KeyboardEvent -> Boolean
+
+foreign import getModifierState
+  :: forall eff
+   . String
+  -> KeyboardEvent
+  -> Eff (dom :: DOM | eff) Boolean

src/DOM/Event/MouseEvent.js

@@ -0,0 +1,53 @@
+"use strict";
+
+exports.screenX = function (e) {
+  return e.screenX;
+};
+
+exports.screenY = function (e) {
+  return e.screenY;
+};
+
+exports.clientX = function (e) {
+  return e.clientX;
+};
+
+exports.clientY = function (e) {
+  return e.clientY;
+};
+
+exports.ctrlKey = function (e) {
+  return e.ctrlKey;
+};
+
+exports.shiftKey = function (e) {
+  return e.shiftKey;
+};
+
+exports.altKey = function (e) {
+  return e.altKey;
+};
+
+exports.metaKey = function (e) {
+  return e.metaKey;
+};
+
+exports.button = function (e) {
+  return e.button;
+};
+
+exports.relatedTargetNullable = function (e) {
+  return e.relatedTarget;
+};
+
+exports.buttons = function (e) {
+  return e.buttons;
+};
+
+exports.getModifierState = function (s) {
+  return function (e) {
+    return function () {
+      return e.getModifierState(s);
+    };
+  };
+};

src/DOM/Event/MouseEvent.purs

@@ -0,0 +1,59 @@
+module DOM.Event.MouseEvent
+  ( module T
+  , eventToMouseEvent
+  , screenX
+  , screenY
+  , clientX
+  , clientY
+  , ctrlKey
+  , shiftKey
+  , altKey
+  , metaKey
+  , button
+  , relatedTarget
+  , buttons
+  , getModifierState
+  ) where
+
+import Prelude
+import Control.Monad.Eff (Eff)
+import Data.Foreign (F, toForeign)
+import Data.Maybe (Maybe)
+import Data.Nullable (Nullable, toMaybe)
+import DOM (DOM)
+import DOM.Event.Types (Event, EventTarget, MouseEvent, readMouseEvent)
+import DOM.Event.Types (MouseEvent, mouseEventToEvent, readMouseEvent) as T
+
+eventToMouseEvent :: Event -> F MouseEvent
+eventToMouseEvent = readMouseEvent <<< toForeign
+
+foreign import screenX :: MouseEvent -> Int
+
+foreign import screenY :: MouseEvent -> Int
+
+foreign import clientX :: MouseEvent -> Int
+
+foreign import clientY :: MouseEvent -> Int
+
+foreign import ctrlKey :: MouseEvent -> Boolean
+
+foreign import shiftKey :: MouseEvent -> Boolean
+
+foreign import altKey :: MouseEvent -> Boolean
+
+foreign import metaKey :: MouseEvent -> Boolean
+
+foreign import button :: MouseEvent -> Int
+
+foreign import relatedTargetNullable :: MouseEvent -> Nullable EventTarget
+
+relatedTarget :: MouseEvent -> Maybe EventTarget
+relatedTarget = toMaybe <$> relatedTargetNullable
+
+foreign import buttons :: MouseEvent -> Int
+
+foreign import getModifierState
+  :: forall eff
+   . String
+  -> MouseEvent
+  -> Eff (dom :: DOM | eff) Boolean

src/DOM/Event/WheelEvent.js

@@ -0,0 +1,17 @@
+"use strict";
+
+exports.deltaX = function (e) {
+  return e.deltaX;
+};
+
+exports.deltaY = function (e) {
+  return e.deltaY;
+};
+
+exports.deltaZ = function (e) {
+  return e.deltaZ;
+};
+
+exports.deltaModeIndex = function (e) {
+  return e.deltaModeIndex;
+};

src/DOM/Event/WheelEvent.purs

@@ -0,0 +1,69 @@
+module DOM.Event.WheelEvent
+  ( module T
+  , eventToWheelEvent
+  , deltaX
+  , deltaY
+  , deltaZ
+  , deltaModeIndex
+  , deltaMode
+  , DeltaMode(..)
+  , toEnumDeltaMode
+  , fromEnumDeltaMode
+  ) where
+
+import Prelude
+import Data.Enum (class BoundedEnum, class Enum, Cardinality(..), defaultPred, defaultSucc, toEnum)
+import Data.Foreign (F, toForeign)
+import Data.Maybe (Maybe(..), fromJust)
+import DOM.Event.Types (Event, WheelEvent, readWheelEvent)
+import DOM.Event.Types (WheelEvent, readWheelEvent, wheelEventToEvent) as T
+
+eventToWheelEvent :: Event -> F WheelEvent
+eventToWheelEvent = readWheelEvent <<< toForeign
+
+foreign import deltaX :: WheelEvent -> Number
+
+foreign import deltaY :: WheelEvent -> Number
+
+foreign import deltaZ :: WheelEvent -> Number
+
+foreign import deltaModeIndex :: WheelEvent -> Int
+
+deltaMode :: Partial => WheelEvent -> DeltaMode
+deltaMode = fromJust <<< toEnum <<< deltaModeIndex
+
+data DeltaMode
+  = Pixel
+  | Line
+  | Page
+
+derive instance eqDeltaMode :: Eq DeltaMode
+derive instance ordDeltaMode :: Ord DeltaMode
+
+instance boundedDeltaMode :: Bounded DeltaMode where
+  bottom = Pixel
+  top = Page
+
+instance enumDeltaMode :: Enum DeltaMode where
+  succ = defaultSucc toEnumDeltaMode fromEnumDeltaMode
+  pred = defaultPred toEnumDeltaMode fromEnumDeltaMode
+
+instance boundedEnumDeltaMode :: BoundedEnum DeltaMode where
+  cardinality = Cardinality 3
+  toEnum = toEnumDeltaMode
+  fromEnum = fromEnumDeltaMode
+
+toEnumDeltaMode :: Int -> Maybe DeltaMode
+toEnumDeltaMode =
+  case _ of
+    0 -> Just Pixel
+    1 -> Just Line
+    2 -> Just Page
+    _ -> Nothing
+
+fromEnumDeltaMode :: DeltaMode -> Int
+fromEnumDeltaMode =
+  case _ of
+    Pixel -> 0
+    Line -> 1
+    Page -> 2