module GHCJS.DOM.JSFFI.Generated.HTMLSelectElement
(js_item, item, item_, itemUnsafe, itemUnchecked, js_namedItem,
namedItem, namedItem_, namedItemUnsafe, namedItemUnchecked,
js_addBefore, addBefore, js_add, add, js_remove, remove,
js_checkValidity, checkValidity, checkValidity_,
js_setCustomValidity, setCustomValidity, js_setAutofocus,
setAutofocus, js_getAutofocus, getAutofocus, js_setDisabled,
setDisabled, js_getDisabled, getDisabled, js_getForm, getForm,
getFormUnsafe, getFormUnchecked, js_setMultiple, setMultiple,
js_getMultiple, getMultiple, js_setName, setName, js_getName,
getName, js_setRequired, setRequired, js_getRequired, getRequired,
js_setSize, setSize, js_getSize, getSize, js_getType, getType,
js_getOptions, getOptions, getOptionsUnsafe, getOptionsUnchecked,
js_setLength, setLength, js_getLength, getLength,
js_getSelectedOptions, getSelectedOptions,
getSelectedOptionsUnsafe, getSelectedOptionsUnchecked,
js_setSelectedIndex, setSelectedIndex, js_getSelectedIndex,
getSelectedIndex, js_setValue, setValue, js_getValue, getValue,
getValueUnsafe, getValueUnchecked, js_getWillValidate,
getWillValidate, js_getValidity, getValidity, getValidityUnsafe,
getValidityUnchecked, js_getValidationMessage,
getValidationMessage, js_getLabels, getLabels, getLabelsUnsafe,
getLabelsUnchecked, HTMLSelectElement(..), gTypeHTMLSelectElement)
where
import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
import qualified Prelude (error)
import Data.Typeable (Typeable)
import GHCJS.Types (JSVal(..), JSString)
import GHCJS.Foreign (jsNull)
import GHCJS.Foreign.Callback (syncCallback, asyncCallback, syncCallback1, asyncCallback1, syncCallback2, asyncCallback2, OnBlocked(..))
import GHCJS.Marshal (ToJSVal(..), FromJSVal(..))
import GHCJS.Marshal.Pure (PToJSVal(..), PFromJSVal(..))
import Control.Monad (void)
import Control.Monad.IO.Class (MonadIO(..))
import Data.Int (Int64)
import Data.Word (Word, Word64)
import Data.Maybe (fromJust)
import GHCJS.DOM.Types
import Control.Applicative ((<$>))
import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
import GHCJS.DOM.JSFFI.Generated.Enums
foreign import javascript unsafe "$1[\"item\"]($2)" js_item ::
HTMLSelectElement -> Word -> IO (Nullable Node)
item :: (MonadIO m) => HTMLSelectElement -> Word -> m (Maybe Node)
item self index
= liftIO (nullableToMaybe <$> (js_item (self) index))
item_ :: (MonadIO m) => HTMLSelectElement -> Word -> m ()
item_ self index = liftIO (void (js_item (self) index))
itemUnsafe ::
(MonadIO m, HasCallStack) => HTMLSelectElement -> Word -> m Node
itemUnsafe self index
= liftIO
((nullableToMaybe <$> (js_item (self) index)) >>=
maybe (Prelude.error "Nothing to return") return)
itemUnchecked :: (MonadIO m) => HTMLSelectElement -> Word -> m Node
itemUnchecked self index
= liftIO (fromJust . nullableToMaybe <$> (js_item (self) index))
foreign import javascript unsafe "$1[\"namedItem\"]($2)"
js_namedItem :: HTMLSelectElement -> JSString -> IO (Nullable Node)
namedItem ::
(MonadIO m, ToJSString name) =>
HTMLSelectElement -> name -> m (Maybe Node)
namedItem self name
= liftIO
(nullableToMaybe <$> (js_namedItem (self) (toJSString name)))
namedItem_ ::
(MonadIO m, ToJSString name) => HTMLSelectElement -> name -> m ()
namedItem_ self name
= liftIO (void (js_namedItem (self) (toJSString name)))
namedItemUnsafe ::
(MonadIO m, ToJSString name, HasCallStack) =>
HTMLSelectElement -> name -> m Node
namedItemUnsafe self name
= liftIO
((nullableToMaybe <$> (js_namedItem (self) (toJSString name))) >>=
maybe (Prelude.error "Nothing to return") return)
namedItemUnchecked ::
(MonadIO m, ToJSString name) => HTMLSelectElement -> name -> m Node
namedItemUnchecked self name
= liftIO
(fromJust . nullableToMaybe <$>
(js_namedItem (self) (toJSString name)))
foreign import javascript unsafe "$1[\"add\"]($2, $3)" js_addBefore
::
HTMLSelectElement ->
Nullable HTMLElement -> Nullable HTMLElement -> IO ()
addBefore ::
(MonadIO m, IsHTMLElement element, IsHTMLElement before) =>
HTMLSelectElement -> Maybe element -> Maybe before -> m ()
addBefore self element before
= liftIO
(js_addBefore (self) (maybeToNullable (fmap toHTMLElement element))
(maybeToNullable (fmap toHTMLElement before)))
foreign import javascript unsafe "$1[\"add\"]($2, $3)" js_add ::
HTMLSelectElement -> Nullable HTMLElement -> Int -> IO ()
add ::
(MonadIO m, IsHTMLElement element) =>
HTMLSelectElement -> Maybe element -> Int -> m ()
add self element index
= liftIO
(js_add (self) (maybeToNullable (fmap toHTMLElement element))
index)
foreign import javascript unsafe "$1[\"remove\"]()" js_remove ::
HTMLSelectElement -> IO ()
remove :: (MonadIO m) => HTMLSelectElement -> m ()
remove self = liftIO (js_remove (self))
foreign import javascript unsafe
"($1[\"checkValidity\"]() ? 1 : 0)" js_checkValidity ::
HTMLSelectElement -> IO Bool
checkValidity :: (MonadIO m) => HTMLSelectElement -> m Bool
checkValidity self = liftIO (js_checkValidity (self))
checkValidity_ :: (MonadIO m) => HTMLSelectElement -> m ()
checkValidity_ self = liftIO (void (js_checkValidity (self)))
foreign import javascript unsafe "$1[\"setCustomValidity\"]($2)"
js_setCustomValidity ::
HTMLSelectElement -> Nullable JSString -> IO ()
setCustomValidity ::
(MonadIO m, ToJSString error) =>
HTMLSelectElement -> Maybe error -> m ()
setCustomValidity self error
= liftIO (js_setCustomValidity (self) (toMaybeJSString error))
foreign import javascript unsafe "$1[\"autofocus\"] = $2;"
js_setAutofocus :: HTMLSelectElement -> Bool -> IO ()
setAutofocus :: (MonadIO m) => HTMLSelectElement -> Bool -> m ()
setAutofocus self val = liftIO (js_setAutofocus (self) val)
foreign import javascript unsafe "($1[\"autofocus\"] ? 1 : 0)"
js_getAutofocus :: HTMLSelectElement -> IO Bool
getAutofocus :: (MonadIO m) => HTMLSelectElement -> m Bool
getAutofocus self = liftIO (js_getAutofocus (self))
foreign import javascript unsafe "$1[\"disabled\"] = $2;"
js_setDisabled :: HTMLSelectElement -> Bool -> IO ()
setDisabled :: (MonadIO m) => HTMLSelectElement -> Bool -> m ()
setDisabled self val = liftIO (js_setDisabled (self) val)
foreign import javascript unsafe "($1[\"disabled\"] ? 1 : 0)"
js_getDisabled :: HTMLSelectElement -> IO Bool
getDisabled :: (MonadIO m) => HTMLSelectElement -> m Bool
getDisabled self = liftIO (js_getDisabled (self))
foreign import javascript unsafe "$1[\"form\"]" js_getForm ::
HTMLSelectElement -> IO (Nullable HTMLFormElement)
getForm ::
(MonadIO m) => HTMLSelectElement -> m (Maybe HTMLFormElement)
getForm self = liftIO (nullableToMaybe <$> (js_getForm (self)))
getFormUnsafe ::
(MonadIO m, HasCallStack) => HTMLSelectElement -> m HTMLFormElement
getFormUnsafe self
= liftIO
((nullableToMaybe <$> (js_getForm (self))) >>=
maybe (Prelude.error "Nothing to return") return)
getFormUnchecked ::
(MonadIO m) => HTMLSelectElement -> m HTMLFormElement
getFormUnchecked self
= liftIO (fromJust . nullableToMaybe <$> (js_getForm (self)))
foreign import javascript unsafe "$1[\"multiple\"] = $2;"
js_setMultiple :: HTMLSelectElement -> Bool -> IO ()
setMultiple :: (MonadIO m) => HTMLSelectElement -> Bool -> m ()
setMultiple self val = liftIO (js_setMultiple (self) val)
foreign import javascript unsafe "($1[\"multiple\"] ? 1 : 0)"
js_getMultiple :: HTMLSelectElement -> IO Bool
getMultiple :: (MonadIO m) => HTMLSelectElement -> m Bool
getMultiple self = liftIO (js_getMultiple (self))
foreign import javascript unsafe "$1[\"name\"] = $2;" js_setName ::
HTMLSelectElement -> JSString -> IO ()
setName ::
(MonadIO m, ToJSString val) => HTMLSelectElement -> val -> m ()
setName self val = liftIO (js_setName (self) (toJSString val))
foreign import javascript unsafe "$1[\"name\"]" js_getName ::
HTMLSelectElement -> IO JSString
getName ::
(MonadIO m, FromJSString result) => HTMLSelectElement -> m result
getName self = liftIO (fromJSString <$> (js_getName (self)))
foreign import javascript unsafe "$1[\"required\"] = $2;"
js_setRequired :: HTMLSelectElement -> Bool -> IO ()
setRequired :: (MonadIO m) => HTMLSelectElement -> Bool -> m ()
setRequired self val = liftIO (js_setRequired (self) val)
foreign import javascript unsafe "($1[\"required\"] ? 1 : 0)"
js_getRequired :: HTMLSelectElement -> IO Bool
getRequired :: (MonadIO m) => HTMLSelectElement -> m Bool
getRequired self = liftIO (js_getRequired (self))
foreign import javascript unsafe "$1[\"size\"] = $2;" js_setSize ::
HTMLSelectElement -> Int -> IO ()
setSize :: (MonadIO m) => HTMLSelectElement -> Int -> m ()
setSize self val = liftIO (js_setSize (self) val)
foreign import javascript unsafe "$1[\"size\"]" js_getSize ::
HTMLSelectElement -> IO Int
getSize :: (MonadIO m) => HTMLSelectElement -> m Int
getSize self = liftIO (js_getSize (self))
foreign import javascript unsafe "$1[\"type\"]" js_getType ::
HTMLSelectElement -> IO JSString
getType ::
(MonadIO m, FromJSString result) => HTMLSelectElement -> m result
getType self = liftIO (fromJSString <$> (js_getType (self)))
foreign import javascript unsafe "$1[\"options\"]" js_getOptions ::
HTMLSelectElement -> IO (Nullable HTMLOptionsCollection)
getOptions ::
(MonadIO m) => HTMLSelectElement -> m (Maybe HTMLOptionsCollection)
getOptions self
= liftIO (nullableToMaybe <$> (js_getOptions (self)))
getOptionsUnsafe ::
(MonadIO m, HasCallStack) =>
HTMLSelectElement -> m HTMLOptionsCollection
getOptionsUnsafe self
= liftIO
((nullableToMaybe <$> (js_getOptions (self))) >>=
maybe (Prelude.error "Nothing to return") return)
getOptionsUnchecked ::
(MonadIO m) => HTMLSelectElement -> m HTMLOptionsCollection
getOptionsUnchecked self
= liftIO (fromJust . nullableToMaybe <$> (js_getOptions (self)))
foreign import javascript unsafe "$1[\"length\"] = $2;"
js_setLength :: HTMLSelectElement -> Word -> IO ()
setLength :: (MonadIO m) => HTMLSelectElement -> Word -> m ()
setLength self val = liftIO (js_setLength (self) val)
foreign import javascript unsafe "$1[\"length\"]" js_getLength ::
HTMLSelectElement -> IO Word
getLength :: (MonadIO m) => HTMLSelectElement -> m Word
getLength self = liftIO (js_getLength (self))
foreign import javascript unsafe "$1[\"selectedOptions\"]"
js_getSelectedOptions ::
HTMLSelectElement -> IO (Nullable HTMLCollection)
getSelectedOptions ::
(MonadIO m) => HTMLSelectElement -> m (Maybe HTMLCollection)
getSelectedOptions self
= liftIO (nullableToMaybe <$> (js_getSelectedOptions (self)))
getSelectedOptionsUnsafe ::
(MonadIO m, HasCallStack) => HTMLSelectElement -> m HTMLCollection
getSelectedOptionsUnsafe self
= liftIO
((nullableToMaybe <$> (js_getSelectedOptions (self))) >>=
maybe (Prelude.error "Nothing to return") return)
getSelectedOptionsUnchecked ::
(MonadIO m) => HTMLSelectElement -> m HTMLCollection
getSelectedOptionsUnchecked self
= liftIO
(fromJust . nullableToMaybe <$> (js_getSelectedOptions (self)))
foreign import javascript unsafe "$1[\"selectedIndex\"] = $2;"
js_setSelectedIndex :: HTMLSelectElement -> Int -> IO ()
setSelectedIndex :: (MonadIO m) => HTMLSelectElement -> Int -> m ()
setSelectedIndex self val = liftIO (js_setSelectedIndex (self) val)
foreign import javascript unsafe "$1[\"selectedIndex\"]"
js_getSelectedIndex :: HTMLSelectElement -> IO Int
getSelectedIndex :: (MonadIO m) => HTMLSelectElement -> m Int
getSelectedIndex self = liftIO (js_getSelectedIndex (self))
foreign import javascript unsafe "$1[\"value\"] = $2;" js_setValue
:: HTMLSelectElement -> Nullable JSString -> IO ()
setValue ::
(MonadIO m, ToJSString val) =>
HTMLSelectElement -> Maybe val -> m ()
setValue self val
= liftIO (js_setValue (self) (toMaybeJSString val))
foreign import javascript unsafe "$1[\"value\"]" js_getValue ::
HTMLSelectElement -> IO (Nullable JSString)
getValue ::
(MonadIO m, FromJSString result) =>
HTMLSelectElement -> m (Maybe result)
getValue self = liftIO (fromMaybeJSString <$> (js_getValue (self)))
getValueUnsafe ::
(MonadIO m, HasCallStack, FromJSString result) =>
HTMLSelectElement -> m result
getValueUnsafe self
= liftIO
((fromMaybeJSString <$> (js_getValue (self))) >>=
maybe (Prelude.error "Nothing to return") return)
getValueUnchecked ::
(MonadIO m, FromJSString result) => HTMLSelectElement -> m result
getValueUnchecked self
= liftIO (fromJust . fromMaybeJSString <$> (js_getValue (self)))
foreign import javascript unsafe "($1[\"willValidate\"] ? 1 : 0)"
js_getWillValidate :: HTMLSelectElement -> IO Bool
getWillValidate :: (MonadIO m) => HTMLSelectElement -> m Bool
getWillValidate self = liftIO (js_getWillValidate (self))
foreign import javascript unsafe "$1[\"validity\"]" js_getValidity
:: HTMLSelectElement -> IO (Nullable ValidityState)
getValidity ::
(MonadIO m) => HTMLSelectElement -> m (Maybe ValidityState)
getValidity self
= liftIO (nullableToMaybe <$> (js_getValidity (self)))
getValidityUnsafe ::
(MonadIO m, HasCallStack) => HTMLSelectElement -> m ValidityState
getValidityUnsafe self
= liftIO
((nullableToMaybe <$> (js_getValidity (self))) >>=
maybe (Prelude.error "Nothing to return") return)
getValidityUnchecked ::
(MonadIO m) => HTMLSelectElement -> m ValidityState
getValidityUnchecked self
= liftIO (fromJust . nullableToMaybe <$> (js_getValidity (self)))
foreign import javascript unsafe "$1[\"validationMessage\"]"
js_getValidationMessage :: HTMLSelectElement -> IO JSString
getValidationMessage ::
(MonadIO m, FromJSString result) => HTMLSelectElement -> m result
getValidationMessage self
= liftIO (fromJSString <$> (js_getValidationMessage (self)))
foreign import javascript unsafe "$1[\"labels\"]" js_getLabels ::
HTMLSelectElement -> IO (Nullable NodeList)
getLabels :: (MonadIO m) => HTMLSelectElement -> m (Maybe NodeList)
getLabels self = liftIO (nullableToMaybe <$> (js_getLabels (self)))
getLabelsUnsafe ::
(MonadIO m, HasCallStack) => HTMLSelectElement -> m NodeList
getLabelsUnsafe self
= liftIO
((nullableToMaybe <$> (js_getLabels (self))) >>=
maybe (Prelude.error "Nothing to return") return)
getLabelsUnchecked ::
(MonadIO m) => HTMLSelectElement -> m NodeList
getLabelsUnchecked self
= liftIO (fromJust . nullableToMaybe <$> (js_getLabels (self)))