WIP

Author: garyb

src/DOM/HTML/HTMLMediaElement.purs

@@ -1,13 +1,18 @@
 module DOM.HTML.HTMLMediaElement where
 
-import Prelude (Unit())
+import Prelude (Unit(), (<<<))
 
 import Control.Monad.Eff (Eff())
 
+import Data.Enum (toEnum)
+import Data.Maybe.Unsafe as U
+
 import DOM (DOM())
+import DOM.HTML.HTMLMediaElement.NetworkState (NetworkState())
+import DOM.HTML.HTMLMediaElement.ReadyState (ReadyState())
+import DOM.HTML.HTMLMediaElement.CanPlayType (CanPlayType())
 import DOM.HTML.Types (HTMLMediaElement())
 
--- enum CanPlayTypeEnum { "" /* empty string */, "maybe", "probably" };
 -- interface HTMLMediaElement : HTMLElement {
 
 --   // error state
@@ -17,23 +22,22 @@ import DOM.HTML.Types (HTMLMediaElement())
 --            attribute DOMString src;
 --   readonly attribute DOMString currentSrc;
 --            attribute DOMString crossOrigin;
---   const unsigned short NETWORK_EMPTY = 0;
---   const unsigned short NETWORK_IDLE = 1;
---   const unsigned short NETWORK_LOADING = 2;
---   const unsigned short NETWORK_NO_SOURCE = 3;
---   readonly attribute unsigned short networkState;
+
+networkState :: HTMLMediaElement -> NetworkState
+networkState = U.fromJust <<< toEnum <<< readyStateIndex
+
+foreign import networkStateIndex :: HTMLMediaElement -> Int
+
 --            attribute DOMString preload;
 --   readonly attribute TimeRanges buffered;
 --   void load();
---   CanPlayTypeEnum canPlayType(DOMString type);
-
---   // ready state
---   const unsigned short HAVE_NOTHING = 0;
---   const unsigned short HAVE_METADATA = 1;
---   const unsigned short HAVE_CURRENT_DATA = 2;
---   const unsigned short HAVE_FUTURE_DATA = 3;
---   const unsigned short HAVE_ENOUGH_DATA = 4;
---   readonly attribute unsigned short readyState;
+--   CanPlayType canPlayType(DOMString type);
+
+readyState :: HTMLMediaElement -> ReadyState
+readyState = U.fromJust <<< toEnum <<< readyStateIndex
+
+foreign import readyStateIndex :: HTMLMediaElement -> Int
+
 --   readonly attribute boolean seeking;
 
 --   // playback state
@@ -66,5 +70,3 @@ import DOM.HTML.Types (HTMLMediaElement())
 --   readonly attribute VideoTrackList videoTracks;
 --   readonly attribute TextTrackList textTracks;
 --   TextTrack addTextTrack(TextTrackKind kind, optional DOMString label = "", optional DOMString language = "");
--- };
-

src/DOM/HTML/HTMLMediaElement/CanPlayType

@@ -0,0 +1,34 @@
+module DOM.HTML.HTMLMediaElement.CanPlayType
+  ( CanPlayType()
+  , runCanPlayType
+  , unspecified
+  , maybe
+  , probably
+  ) where
+
+import Prelude
+import Data.Maybe (Maybe(..))
+import Data.Enum (Enum, Cardinality(..), defaultSucc, defaultPred)
+
+newtype CanPlayType = CanPlayType String
+
+runCanPlayType :: CanPlayType -> String
+runCanPlayType (CanPlayType t) = t
+
+instance eqCanPlayType :: Eq CanPlayType where
+  eq (CanPlayType x) (CanPlayType y) = x == y
+
+instance ordCanPlayType :: Ord CanPlayType where
+  compare (CanPlayType x) (CanPlayType y) = compare x y
+
+instance showCanPlayType :: Ord CanPlayType where
+  show (CanPlayType t) = "(CanPlayType " <> show t <> ")"
+
+unspecified :: CanPlayType
+unspecified = CanPlayType ""
+
+maybe :: CanPlayType
+maybe = CanPlayType "maybe"
+
+probably :: CanPlayType
+probably = CanPlayType "probably"

src/DOM/HTML/HTMLMediaElement/NetworkState

@@ -0,0 +1,47 @@
+module DOM.HTML.HTMLMediaElement.NetworkState (NetworkState(..)) where
+
+import Prelude
+import Data.Maybe (Maybe(..))
+import Data.Enum (Enum, Cardinality(..), defaultSucc, defaultPred)
+
+data NetworkState
+  = NETWORK_EMPTY
+  | NETWORK_IDLE
+  | NETWORK_LOADING
+  | NETWORK_NO_SOURCE
+
+instance eqNetworkState :: Eq NetworkState where
+  eq NETWORK_EMPTY NETWORK_EMPTY = true
+  eq NETWORK_IDLE NETWORK_IDLE = true
+  eq NETWORK_LOADING NETWORK_LOADING = true
+  eq NETWORK_NO_SOURCE NETWORK_NO_SOURCE = true
+  eq _ _ = false
+
+instance ordNetworkState :: Ord NetworkState where
+  compare x y = compare (fromEnumNetworkState x) (fromEnumNetworkState y)
+
+instance boundedNetworkState :: Bounded NetworkState where
+  bottom = NETWORK_EMPTY
+  top = NETWORK_NO_SOURCE
+
+instance boundedOrdNetworkState :: BoundedOrd NetworkState
+
+instance enumNetworkState :: Enum NetworkState where
+  cardinality = Cardinality 4
+  succ = defaultSucc toEnumNetworkState fromEnumNetworkState
+  pred = defaultPred toEnumNetworkState fromEnumNetworkState
+  toEnum = toEnumNetworkState
+  fromEnum = fromEnumNetworkState
+
+toEnumNetworkState :: Int -> Maybe NetworkState
+toEnumNetworkState 0 = Just NETWORK_EMPTY
+toEnumNetworkState 1 = Just NETWORK_IDLE
+toEnumNetworkState 2 = Just NETWORK_LOADING
+toEnumNetworkState 3 = Just NETWORK_NO_SOURCE
+toEnumNetworkState _ = Nothing
+
+fromEnumNetworkState :: NetworkState -> Int
+fromEnumNetworkState NETWORK_EMPTY = 0
+fromEnumNetworkState NETWORK_IDLE = 1
+fromEnumNetworkState NETWORK_LOADING = 2
+fromEnumNetworkState NETWORK_NO_SOURCE = 3

src/DOM/HTML/HTMLMediaElement/ReadyState.purs

@@ -0,0 +1,51 @@
+module DOM.HTML.HTMLMediaElement.ReadyState (ReadyState(..)) where
+
+import Prelude
+import Data.Maybe (Maybe(..))
+import Data.Enum (Enum, Cardinality(..), defaultSucc, defaultPred)
+
+data ReadyState
+  = HAVE_NOTHING
+  | HAVE_METADATA
+  | HAVE_CURRENT_DATA
+  | HAVE_FUTURE_DATA
+  | HAVE_ENOUGH_DATA
+
+instance eqReadyState :: Eq ReadyState where
+  eq HAVE_NOTHING HAVE_NOTHING = true
+  eq HAVE_METADATA HAVE_METADATA = true
+  eq HAVE_CURRENT_DATA HAVE_CURRENT_DATA = true
+  eq HAVE_FUTURE_DATA HAVE_FUTURE_DATA = true
+  eq HAVE_ENOUGH_DATA HAVE_ENOUGH_DATA = true
+  eq _ _ = false
+
+instance ordReadyState :: Ord ReadyState where
+  compare x y = compare (fromEnumReadyState x) (fromEnumReadyState y)
+
+instance boundedReadyState :: Bounded ReadyState where
+  bottom = HAVE_NOTHING
+  top = HAVE_ENOUGH_DATA
+
+instance boundedOrdReadyState :: BoundedOrd ReadyState
+
+instance enumReadyState :: Enum ReadyState where
+  cardinality = Cardinality 5
+  succ = defaultSucc toEnumReadyState fromEnumReadyState
+  pred = defaultPred toEnumReadyState fromEnumReadyState
+  toEnum = toEnumReadyState
+  fromEnum = fromEnumReadyState
+
+toEnumReadyState :: Int -> Maybe ReadyState
+toEnumReadyState 0 = Just HAVE_NOTHING
+toEnumReadyState 1 = Just HAVE_METADATA
+toEnumReadyState 2 = Just HAVE_CURRENT_DATA
+toEnumReadyState 3 = Just HAVE_FUTURE_DATA
+toEnumReadyState 4 = Just HAVE_ENOUGH_DATA
+toEnumReadyState _ = Nothing
+
+fromEnumReadyState :: ReadyState -> Int
+fromEnumReadyState HAVE_NOTHING = 0
+fromEnumReadyState HAVE_METADATA = 1
+fromEnumReadyState HAVE_CURRENT_DATA = 2
+fromEnumReadyState HAVE_FUTURE_DATA = 3
+fromEnumReadyState HAVE_ENOUGH_DATA = 4

src/DOM/HTML/HTMLTrackElement.purs

@@ -8,8 +8,8 @@ import Data.Enum (toEnum)
 import Data.Maybe.Unsafe as U
 
 import DOM (DOM())
+import DOM.HTML.HTMLTrackElement.ReadyState (ReadyState())
 import DOM.HTML.Types (HTMLTrackElement())
-import DOM.HTML.ReadyState (ReadyState())
 
 foreign import kind :: forall eff. HTMLTrackElement -> Eff (dom :: DOM | eff) String
 foreign import setKind :: forall eff. String -> HTMLTrackElement -> Eff (dom :: DOM | eff) Unit

src/DOM/HTML/ReadyState.purs renamed to src/DOM/HTML/HTMLTrackElement/ReadyState.purs

@@ -1,4 +1,4 @@
-module DOM.HTML.ReadyState (ReadyState(..)) where
+module DOM.HTML.HTMLTrackElement.ReadyState (ReadyState(..)) where
 
 import Prelude
 import Data.Maybe (Maybe(..))

src/DOM/HTML/SelectionMode.purs

@@ -21,7 +21,7 @@ instance ordSelectionMode :: Ord SelectionMode where
   compare (SelectionMode x) (SelectionMode y) = compare x y
 
 instance showSelectionMode :: Show SelectionMode where
-  show (SelectionMode m) = "(SelectionMode " <> m <> ")"
+  show (SelectionMode m) = "(SelectionMode " <> show m <> ")"
 
 select :: SelectionMode
 select = SelectionMode "select"