diff --git a/Graphics/UI/Gtk/WebKit/DOM/ApplicationCache.chs b/Graphics/UI/Gtk/WebKit/DOM/ApplicationCache.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/ApplicationCache.chs @@ -0,0 +1,102 @@ +module Graphics.UI.Gtk.WebKit.DOM.ApplicationCache( +update, +swapCache, +abort, +pattern UNCACHED, +pattern IDLE, +pattern CHECKING, +pattern DOWNLOADING, +pattern UPDATEREADY, +pattern OBSOLETE, +getStatus, +checking, +error, +noUpdate, +downloading, +progress, +updateReady, +cached, +obsolete, +ApplicationCache, +castToApplicationCache, +gTypeApplicationCache, +ApplicationCacheClass, +toApplicationCache, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures +import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + + +update :: (MonadIO m, ApplicationCacheClass self) => self -> m () +update self + = liftIO + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_dom_application_cache_update #} + (toApplicationCache self) + errorPtr_) + +swapCache :: + (MonadIO m, ApplicationCacheClass self) => self -> m () +swapCache self + = liftIO + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_dom_application_cache_swap_cache #} + (toApplicationCache self) + errorPtr_) + +abort :: (MonadIO m, ApplicationCacheClass self) => self -> m () +abort self + = liftIO + ({# call webkit_dom_dom_application_cache_abort #} + (toApplicationCache self)) +pattern UNCACHED = 0 +pattern IDLE = 1 +pattern CHECKING = 2 +pattern DOWNLOADING = 3 +pattern UPDATEREADY = 4 +pattern OBSOLETE = 5 + +getStatus :: + (MonadIO m, ApplicationCacheClass self) => self -> m Word +getStatus self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_dom_application_cache_get_status #} + (toApplicationCache self))) + +checking :: (ApplicationCacheClass self) => EventName self Event +checking = EventName "checking" + +error :: (ApplicationCacheClass self) => EventName self UIEvent +error = EventName "error" + +noUpdate :: (ApplicationCacheClass self) => EventName self Event +noUpdate = EventName "noupdate" + +downloading :: (ApplicationCacheClass self) => EventName self Event +downloading = EventName "downloading" + +progress :: (ApplicationCacheClass self) => EventName self Event +progress = EventName "progress" + +updateReady :: (ApplicationCacheClass self) => EventName self Event +updateReady = EventName "updateready" + +cached :: (ApplicationCacheClass self) => EventName self Event +cached = EventName "cached" + +obsolete :: (ApplicationCacheClass self) => EventName self Event +obsolete = EventName "obsolete" diff --git a/Graphics/UI/Gtk/WebKit/DOM/Attr.chs b/Graphics/UI/Gtk/WebKit/DOM/Attr.chs --- a/Graphics/UI/Gtk/WebKit/DOM/Attr.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/Attr.chs @@ -1,46 +1,73 @@ -module Graphics.UI.Gtk.WebKit.DOM.Attr - (attrGetName, attrGetSpecified, attrSetValue, attrGetValue, - attrGetOwnerElement, attrGetIsId, DOMAttr, DOMAttrClass, - castToDOMAttr, gTypeDOMAttr, toDOMAttr) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.Attr( +getName, +getSpecified, +setValue, +getValue, +getOwnerElement, +getIsId, +Attr, +castToAttr, +gTypeAttr, +AttrClass, +toAttr, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -attrGetName :: (DOMAttrClass self) => self -> IO String -attrGetName self - = ({# call webkit_dom_attr_get_name #} (toDOMAttr self)) >>= - readUTFString +getName :: + (MonadIO m, AttrClass self, GlibString string) => + self -> m (Maybe string) +getName self + = liftIO + (({# call webkit_dom_attr_get_name #} (toAttr self)) >>= + maybePeek readUTFString) -attrGetSpecified :: (DOMAttrClass self) => self -> IO Bool -attrGetSpecified self - = toBool <$> - ({# call webkit_dom_attr_get_specified #} (toDOMAttr self)) +getSpecified :: (MonadIO m, AttrClass self) => self -> m Bool +getSpecified self + = liftIO + (toBool <$> + ({# call webkit_dom_attr_get_specified #} (toAttr self))) -attrSetValue :: (DOMAttrClass self) => self -> String -> IO () -attrSetValue self val - = propagateGError $ - \ errorPtr_ -> - withUTFString val $ - \ valPtr -> - {# call webkit_dom_attr_set_value #} (toDOMAttr self) valPtr - errorPtr_ +setValue :: + (MonadIO m, AttrClass self, GlibString string) => + self -> (Maybe string) -> m () +setValue self val + = liftIO + (propagateGError $ + \ errorPtr_ -> + maybeWith withUTFString val $ + \ valPtr -> + {# call webkit_dom_attr_set_value #} (toAttr self) valPtr + errorPtr_) -attrGetValue :: (DOMAttrClass self) => self -> IO String -attrGetValue self - = ({# call webkit_dom_attr_get_value #} (toDOMAttr self)) >>= - readUTFString +getValue :: + (MonadIO m, AttrClass self, GlibString string) => + self -> m (Maybe string) +getValue self + = liftIO + (({# call webkit_dom_attr_get_value #} (toAttr self)) >>= + maybePeek readUTFString) -attrGetOwnerElement :: - (DOMAttrClass self) => self -> IO (Maybe Element) -attrGetOwnerElement self - = maybeNull (makeNewGObject mkElement) - ({# call webkit_dom_attr_get_owner_element #} (toDOMAttr self)) +getOwnerElement :: + (MonadIO m, AttrClass self) => self -> m (Maybe Element) +getOwnerElement self + = liftIO + (maybeNull (makeNewGObject mkElement) + ({# call webkit_dom_attr_get_owner_element #} (toAttr self))) -attrGetIsId :: (DOMAttrClass self) => self -> IO Bool -attrGetIsId self - = toBool <$> - ({# call webkit_dom_attr_get_is_id #} (toDOMAttr self)) +getIsId :: (MonadIO m, AttrClass self) => self -> m Bool +getIsId self + = liftIO + (toBool <$> ({# call webkit_dom_attr_get_is_id #} (toAttr self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/AudioTrack.chs b/Graphics/UI/Gtk/WebKit/DOM/AudioTrack.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/AudioTrack.chs @@ -0,0 +1,60 @@ +module Graphics.UI.Gtk.WebKit.DOM.AudioTrack( +#if WEBKIT_CHECK_VERSION(2,2,2) +getId, +getLabel, +setEnabled, +getEnabled, +AudioTrack, +castToAudioTrack, +gTypeAudioTrack, +AudioTrackClass, +toAudioTrack, +#endif +) where +#if WEBKIT_CHECK_VERSION(2,2,2) +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures +import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + + +getId :: + (MonadIO m, AudioTrackClass self, GlibString string) => + self -> m string +getId self + = liftIO + (({# call webkit_dom_audio_track_get_id #} (toAudioTrack self)) >>= + readUTFString) + +getLabel :: + (MonadIO m, AudioTrackClass self, GlibString string) => + self -> m string +getLabel self + = liftIO + (({# call webkit_dom_audio_track_get_label #} (toAudioTrack self)) + >>= + readUTFString) + +setEnabled :: + (MonadIO m, AudioTrackClass self) => self -> Bool -> m () +setEnabled self val + = liftIO + ({# call webkit_dom_audio_track_set_enabled #} (toAudioTrack self) + (fromBool val)) + +getEnabled :: (MonadIO m, AudioTrackClass self) => self -> m Bool +getEnabled self + = liftIO + (toBool <$> + ({# call webkit_dom_audio_track_get_enabled #} + (toAudioTrack self))) +#endif diff --git a/Graphics/UI/Gtk/WebKit/DOM/AudioTrackList.chs b/Graphics/UI/Gtk/WebKit/DOM/AudioTrackList.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/AudioTrackList.chs @@ -0,0 +1,70 @@ +module Graphics.UI.Gtk.WebKit.DOM.AudioTrackList( +#if WEBKIT_CHECK_VERSION(2,2,2) +item, +getTrackById, +getLength, +change, +addTrack, +removeTrack, +AudioTrackList, +castToAudioTrackList, +gTypeAudioTrackList, +AudioTrackListClass, +toAudioTrackList, +#endif +) where +#if WEBKIT_CHECK_VERSION(2,2,2) +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures +import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + + +item :: + (MonadIO m, AudioTrackListClass self) => + self -> Word -> m (Maybe AudioTrack) +item self index + = liftIO + (maybeNull (makeNewGObject mkAudioTrack) + ({# call webkit_dom_audio_track_list_item #} + (toAudioTrackList self) + (fromIntegral index))) + +getTrackById :: + (MonadIO m, AudioTrackListClass self, GlibString string) => + self -> string -> m (Maybe AudioTrack) +getTrackById self id + = liftIO + (maybeNull (makeNewGObject mkAudioTrack) + (withUTFString id $ + \ idPtr -> + {# call webkit_dom_audio_track_list_get_track_by_id #} + (toAudioTrackList self) + idPtr)) + +getLength :: + (MonadIO m, AudioTrackListClass self) => self -> m Word +getLength self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_audio_track_list_get_length #} + (toAudioTrackList self))) + +change :: (AudioTrackListClass self) => EventName self Event +change = EventName "change" + +addTrack :: (AudioTrackListClass self) => EventName self Event +addTrack = EventName "addtrack" + +removeTrack :: (AudioTrackListClass self) => EventName self Event +removeTrack = EventName "removetrack" +#endif diff --git a/Graphics/UI/Gtk/WebKit/DOM/BarProp.chs b/Graphics/UI/Gtk/WebKit/DOM/BarProp.chs --- a/Graphics/UI/Gtk/WebKit/DOM/BarProp.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/BarProp.chs @@ -1,19 +1,32 @@ -module Graphics.UI.Gtk.WebKit.DOM.BarProp ( +module Graphics.UI.Gtk.WebKit.DOM.BarProp( #if WEBKIT_CHECK_VERSION(2,2,2) - barPropGetVisible, BarProp, BarPropClass, castToBarProp, - gTypeBarProp, toBarProp +getVisible, +BarProp, +castToBarProp, +gTypeBarProp, +BarPropClass, +toBarProp, #endif - ) where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +) where +#if WEBKIT_CHECK_VERSION(2,2,2) +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -#if WEBKIT_CHECK_VERSION(2,2,2) -barPropGetVisible :: (BarPropClass self) => self -> IO Bool -barPropGetVisible self - = toBool <$> - ({# call webkit_dom_bar_prop_get_visible #} (toBarProp self)) +getVisible :: (MonadIO m, BarPropClass self) => self -> m Bool +getVisible self + = liftIO + (toBool <$> + ({# call webkit_dom_bar_prop_get_visible #} (toBarProp self))) #endif diff --git a/Graphics/UI/Gtk/WebKit/DOM/BatteryManager.chs b/Graphics/UI/Gtk/WebKit/DOM/BatteryManager.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/BatteryManager.chs @@ -0,0 +1,80 @@ +module Graphics.UI.Gtk.WebKit.DOM.BatteryManager( +#if WEBKIT_CHECK_VERSION(2,2,2) +getCharging, +getChargingTime, +getDischargingTime, +getLevel, +chargingChange, +chargingTimeChange, +dischargingTimeChange, +levelChange, +BatteryManager, +castToBatteryManager, +gTypeBatteryManager, +BatteryManagerClass, +toBatteryManager, +#endif +) where +#if WEBKIT_CHECK_VERSION(2,2,2) +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures +import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + + +getCharging :: + (MonadIO m, BatteryManagerClass self) => self -> m Bool +getCharging self + = liftIO + (toBool <$> + ({# call webkit_dom_battery_manager_get_charging #} + (toBatteryManager self))) + +getChargingTime :: + (MonadIO m, BatteryManagerClass self) => self -> m Double +getChargingTime self + = liftIO + (realToFrac <$> + ({# call webkit_dom_battery_manager_get_charging_time #} + (toBatteryManager self))) + +getDischargingTime :: + (MonadIO m, BatteryManagerClass self) => self -> m Double +getDischargingTime self + = liftIO + (realToFrac <$> + ({# call webkit_dom_battery_manager_get_discharging_time #} + (toBatteryManager self))) + +getLevel :: + (MonadIO m, BatteryManagerClass self) => self -> m Double +getLevel self + = liftIO + (realToFrac <$> + ({# call webkit_dom_battery_manager_get_level #} + (toBatteryManager self))) + +chargingChange :: + (BatteryManagerClass self) => EventName self Event +chargingChange = EventName "chargingchange" + +chargingTimeChange :: + (BatteryManagerClass self) => EventName self Event +chargingTimeChange = EventName "chargingtimechange" + +dischargingTimeChange :: + (BatteryManagerClass self) => EventName self Event +dischargingTimeChange = EventName "dischargingtimechange" + +levelChange :: (BatteryManagerClass self) => EventName self Event +levelChange = EventName "levelchange" +#endif diff --git a/Graphics/UI/Gtk/WebKit/DOM/Blob.chs b/Graphics/UI/Gtk/WebKit/DOM/Blob.chs --- a/Graphics/UI/Gtk/WebKit/DOM/Blob.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/Blob.chs @@ -1,13 +1,41 @@ -module Graphics.UI.Gtk.WebKit.DOM.Blob - (blobGetSize, Blob, BlobClass, castToBlob, gTypeBlob, toBlob) where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.Blob( +slice, +getSize, +Blob, +castToBlob, +gTypeBlob, +BlobClass, +toBlob, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -blobGetSize :: (BlobClass self) => self -> IO Word64 -blobGetSize self - = fromIntegral <$> - ({# call webkit_dom_blob_get_size #} (toBlob self)) +slice :: + (MonadIO m, BlobClass self, GlibString string) => + self -> Int64 -> Int64 -> (Maybe string) -> m (Maybe Blob) +slice self start end contentType + = liftIO + (maybeNull (makeNewGObject mkBlob) + (maybeWith withUTFString contentType $ + \ contentTypePtr -> + {# call webkit_dom_blob_slice #} (toBlob self) (fromIntegral start) + (fromIntegral end) + contentTypePtr)) + +getSize :: (MonadIO m, BlobClass self) => self -> m Word64 +getSize self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_blob_get_size #} (toBlob self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/CSS.chs b/Graphics/UI/Gtk/WebKit/DOM/CSS.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/CSS.chs @@ -0,0 +1,40 @@ +module Graphics.UI.Gtk.WebKit.DOM.CSS( +#if WEBKIT_CHECK_VERSION(2,2,2) +supports2, +CSS, +castToCSS, +gTypeCSS, +CSSClass, +toCSS, +#endif +) where +#if WEBKIT_CHECK_VERSION(2,2,2) +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures +import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + + +supports2 :: + (MonadIO m, CSSClass self, GlibString string) => + self -> string -> string -> m Bool +supports2 self property value + = liftIO + (toBool <$> + (withUTFString value $ + \ valuePtr -> + withUTFString property $ + \ propertyPtr -> + {# call webkit_dom_dom_window_css_supports #} (toCSS self) + propertyPtr + valuePtr)) +#endif diff --git a/Graphics/UI/Gtk/WebKit/DOM/CSSRule.chs b/Graphics/UI/Gtk/WebKit/DOM/CSSRule.chs --- a/Graphics/UI/Gtk/WebKit/DOM/CSSRule.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/CSSRule.chs @@ -1,50 +1,88 @@ -module Graphics.UI.Gtk.WebKit.DOM.CSSRule - (cUNKNOWN_RULE, cSTYLE_RULE, cCHARSET_RULE, cIMPORT_RULE, - cMEDIA_RULE, cFONT_FACE_RULE, cPAGE_RULE, cWEBKIT_KEYFRAMES_RULE, - cWEBKIT_KEYFRAME_RULE, cssRuleSetCssText, cssRuleGetCssText, - cssRuleGetParentStyleSheet, cssRuleGetParentRule, CSSRule, - CSSRuleClass, castToCSSRule, gTypeCSSRule, toCSSRule) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.CSSRule( +pattern UNKNOWN_RULE, +pattern STYLE_RULE, +pattern CHARSET_RULE, +pattern IMPORT_RULE, +pattern MEDIA_RULE, +pattern FONT_FACE_RULE, +pattern PAGE_RULE, +pattern KEYFRAMES_RULE, +pattern KEYFRAME_RULE, +pattern SUPPORTS_RULE, +pattern WEBKIT_VIEWPORT_RULE, +pattern WEBKIT_REGION_RULE, +pattern WEBKIT_KEYFRAMES_RULE, +pattern WEBKIT_KEYFRAME_RULE, +setCssText, +getCssText, +getParentStyleSheet, +getParentRule, +CSSRule, +castToCSSRule, +gTypeCSSRule, +CSSRuleClass, +toCSSRule, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM -cUNKNOWN_RULE = 0 -cSTYLE_RULE = 1 -cCHARSET_RULE = 2 -cIMPORT_RULE = 3 -cMEDIA_RULE = 4 -cFONT_FACE_RULE = 5 -cPAGE_RULE = 6 -cWEBKIT_KEYFRAMES_RULE = 7 -cWEBKIT_KEYFRAME_RULE = 8 +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + +pattern UNKNOWN_RULE = 0 +pattern STYLE_RULE = 1 +pattern CHARSET_RULE = 2 +pattern IMPORT_RULE = 3 +pattern MEDIA_RULE = 4 +pattern FONT_FACE_RULE = 5 +pattern PAGE_RULE = 6 +pattern KEYFRAMES_RULE = 7 +pattern KEYFRAME_RULE = 8 +pattern SUPPORTS_RULE = 12 +pattern WEBKIT_VIEWPORT_RULE = 15 +pattern WEBKIT_REGION_RULE = 16 +pattern WEBKIT_KEYFRAMES_RULE = 7 +pattern WEBKIT_KEYFRAME_RULE = 8 -cssRuleSetCssText :: (CSSRuleClass self) => self -> String -> IO () -cssRuleSetCssText self val - = propagateGError $ - \ errorPtr_ -> - withUTFString val $ - \ valPtr -> - {# call webkit_dom_css_rule_set_css_text #} (toCSSRule self) valPtr - errorPtr_ +setCssText :: + (MonadIO m, CSSRuleClass self, GlibString string) => + self -> (Maybe string) -> m () +setCssText self val + = liftIO + (propagateGError $ + \ errorPtr_ -> + maybeWith withUTFString val $ + \ valPtr -> + {# call webkit_dom_css_rule_set_css_text #} (toCSSRule self) valPtr + errorPtr_) -cssRuleGetCssText :: (CSSRuleClass self) => self -> IO String -cssRuleGetCssText self - = ({# call webkit_dom_css_rule_get_css_text #} (toCSSRule self)) - >>= - readUTFString +getCssText :: + (MonadIO m, CSSRuleClass self, GlibString string) => + self -> m (Maybe string) +getCssText self + = liftIO + (({# call webkit_dom_css_rule_get_css_text #} (toCSSRule self)) >>= + maybePeek readUTFString) -cssRuleGetParentStyleSheet :: - (CSSRuleClass self) => self -> IO (Maybe CSSStyleSheet) -cssRuleGetParentStyleSheet self - = maybeNull (makeNewGObject mkCSSStyleSheet) - ({# call webkit_dom_css_rule_get_parent_style_sheet #} - (toCSSRule self)) +getParentStyleSheet :: + (MonadIO m, CSSRuleClass self) => self -> m (Maybe CSSStyleSheet) +getParentStyleSheet self + = liftIO + (maybeNull (makeNewGObject mkCSSStyleSheet) + ({# call webkit_dom_css_rule_get_parent_style_sheet #} + (toCSSRule self))) -cssRuleGetParentRule :: - (CSSRuleClass self) => self -> IO (Maybe CSSRule) -cssRuleGetParentRule self - = maybeNull (makeNewGObject mkCSSRule) - ({# call webkit_dom_css_rule_get_parent_rule #} (toCSSRule self)) +getParentRule :: + (MonadIO m, CSSRuleClass self) => self -> m (Maybe CSSRule) +getParentRule self + = liftIO + (maybeNull (makeNewGObject mkCSSRule) + ({# call webkit_dom_css_rule_get_parent_rule #} (toCSSRule self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/CSSRuleList.chs b/Graphics/UI/Gtk/WebKit/DOM/CSSRuleList.chs --- a/Graphics/UI/Gtk/WebKit/DOM/CSSRuleList.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/CSSRuleList.chs @@ -1,24 +1,39 @@ -module Graphics.UI.Gtk.WebKit.DOM.CSSRuleList - (cssRuleListItem, cssRuleListGetLength, CSSRuleList, - CSSRuleListClass, castToCSSRuleList, gTypeCSSRuleList, - toCSSRuleList) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.CSSRuleList( +item, +getLength, +CSSRuleList, +castToCSSRuleList, +gTypeCSSRuleList, +CSSRuleListClass, +toCSSRuleList, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -cssRuleListItem :: - (CSSRuleListClass self) => self -> Word -> IO (Maybe CSSRule) -cssRuleListItem self index - = maybeNull (makeNewGObject mkCSSRule) - ({# call webkit_dom_css_rule_list_item #} (toCSSRuleList self) - (fromIntegral index)) +item :: + (MonadIO m, CSSRuleListClass self) => + self -> Word -> m (Maybe CSSRule) +item self index + = liftIO + (maybeNull (makeNewGObject mkCSSRule) + ({# call webkit_dom_css_rule_list_item #} (toCSSRuleList self) + (fromIntegral index))) -cssRuleListGetLength :: (CSSRuleListClass self) => self -> IO Word -cssRuleListGetLength self - = fromIntegral <$> - ({# call webkit_dom_css_rule_list_get_length #} - (toCSSRuleList self)) +getLength :: (MonadIO m, CSSRuleListClass self) => self -> m Word +getLength self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_css_rule_list_get_length #} + (toCSSRuleList self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/CSSStyleDeclaration.chs b/Graphics/UI/Gtk/WebKit/DOM/CSSStyleDeclaration.chs --- a/Graphics/UI/Gtk/WebKit/DOM/CSSStyleDeclaration.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/CSSStyleDeclaration.chs @@ -1,140 +1,171 @@ -module Graphics.UI.Gtk.WebKit.DOM.CSSStyleDeclaration - (cssStyleDeclarationGetPropertyValue, - cssStyleDeclarationRemoveProperty, - cssStyleDeclarationGetPropertyPriority, - cssStyleDeclarationSetProperty, cssStyleDeclarationItem, - cssStyleDeclarationGetPropertyShorthand, - cssStyleDeclarationIsPropertyImplicit, - cssStyleDeclarationSetCssText, cssStyleDeclarationGetCssText, - cssStyleDeclarationGetLength, cssStyleDeclarationGetParentRule, - CSSStyleDeclaration, CSSStyleDeclarationClass, - castToCSSStyleDeclaration, gTypeCSSStyleDeclaration, - toCSSStyleDeclaration) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.CSSStyleDeclaration( +getPropertyValue, +removeProperty, +getPropertyPriority, +setProperty, +item, +getPropertyShorthand, +isPropertyImplicit, +setCssText, +getCssText, +getLength, +getParentRule, +CSSStyleDeclaration, +castToCSSStyleDeclaration, +gTypeCSSStyleDeclaration, +CSSStyleDeclarationClass, +toCSSStyleDeclaration, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -cssStyleDeclarationGetPropertyValue :: - (CSSStyleDeclarationClass self) => self -> String -> IO String -cssStyleDeclarationGetPropertyValue self propertyName - = (withUTFString propertyName $ - \ propertyNamePtr -> - {# call webkit_dom_css_style_declaration_get_property_value #} - (toCSSStyleDeclaration self) - propertyNamePtr) - >>= - readUTFString +getPropertyValue :: + (MonadIO m, CSSStyleDeclarationClass self, GlibString string) => + self -> string -> m (Maybe string) +getPropertyValue self propertyName + = liftIO + ((withUTFString propertyName $ + \ propertyNamePtr -> + {# call webkit_dom_css_style_declaration_get_property_value #} + (toCSSStyleDeclaration self) + propertyNamePtr) + >>= + maybePeek readUTFString) -cssStyleDeclarationRemoveProperty :: - (CSSStyleDeclarationClass self) => self -> String -> IO String -cssStyleDeclarationRemoveProperty self propertyName - = (propagateGError $ - \ errorPtr_ -> - withUTFString propertyName $ - \ propertyNamePtr -> - {# call webkit_dom_css_style_declaration_remove_property #} - (toCSSStyleDeclaration self) - propertyNamePtr - errorPtr_) - >>= - readUTFString +removeProperty :: + (MonadIO m, CSSStyleDeclarationClass self, GlibString string) => + self -> string -> m (Maybe string) +removeProperty self propertyName + = liftIO + ((propagateGError $ + \ errorPtr_ -> + withUTFString propertyName $ + \ propertyNamePtr -> + {# call webkit_dom_css_style_declaration_remove_property #} + (toCSSStyleDeclaration self) + propertyNamePtr + errorPtr_) + >>= + maybePeek readUTFString) -cssStyleDeclarationGetPropertyPriority :: - (CSSStyleDeclarationClass self) => - self -> String -> IO String -cssStyleDeclarationGetPropertyPriority self propertyName - = (withUTFString propertyName $ - \ propertyNamePtr -> - {# call webkit_dom_css_style_declaration_get_property_priority #} - (toCSSStyleDeclaration self) - propertyNamePtr) - >>= - readUTFString +getPropertyPriority :: + (MonadIO m, CSSStyleDeclarationClass self, GlibString string) => + self -> string -> m (Maybe string) +getPropertyPriority self propertyName + = liftIO + ((withUTFString propertyName $ + \ propertyNamePtr -> + {# call webkit_dom_css_style_declaration_get_property_priority #} + (toCSSStyleDeclaration self) + propertyNamePtr) + >>= + maybePeek readUTFString) -cssStyleDeclarationSetProperty :: - (CSSStyleDeclarationClass self) => - self -> String -> String -> String -> IO () -cssStyleDeclarationSetProperty self propertyName value priority - = propagateGError $ - \ errorPtr_ -> - withUTFString priority $ - \ priorityPtr -> - withUTFString value $ - \ valuePtr -> - withUTFString propertyName $ - \ propertyNamePtr -> - {# call webkit_dom_css_style_declaration_set_property #} - (toCSSStyleDeclaration self) - propertyNamePtr - valuePtr - priorityPtr - errorPtr_ +setProperty :: + (MonadIO m, CSSStyleDeclarationClass self, GlibString string) => + self -> string -> (Maybe string) -> string -> m () +setProperty self propertyName value priority + = liftIO + (propagateGError $ + \ errorPtr_ -> + withUTFString priority $ + \ priorityPtr -> + maybeWith withUTFString value $ + \ valuePtr -> + withUTFString propertyName $ + \ propertyNamePtr -> + {# call webkit_dom_css_style_declaration_set_property #} + (toCSSStyleDeclaration self) + propertyNamePtr + valuePtr + priorityPtr + errorPtr_) -cssStyleDeclarationItem :: - (CSSStyleDeclarationClass self) => self -> Word -> IO String -cssStyleDeclarationItem self index - = ({# call webkit_dom_css_style_declaration_item #} - (toCSSStyleDeclaration self) - (fromIntegral index)) - >>= - readUTFString +item :: + (MonadIO m, CSSStyleDeclarationClass self, GlibString string) => + self -> Word -> m string +item self index + = liftIO + (({# call webkit_dom_css_style_declaration_item #} + (toCSSStyleDeclaration self) + (fromIntegral index)) + >>= + readUTFString) -cssStyleDeclarationGetPropertyShorthand :: - (CSSStyleDeclarationClass self) => - self -> String -> IO String -cssStyleDeclarationGetPropertyShorthand self propertyName - = (withUTFString propertyName $ - \ propertyNamePtr -> - {# call webkit_dom_css_style_declaration_get_property_shorthand #} - (toCSSStyleDeclaration self) - propertyNamePtr) - >>= - readUTFString +getPropertyShorthand :: + (MonadIO m, CSSStyleDeclarationClass self, GlibString string) => + self -> string -> m (Maybe string) +getPropertyShorthand self propertyName + = liftIO + ((withUTFString propertyName $ + \ propertyNamePtr -> + {# call webkit_dom_css_style_declaration_get_property_shorthand #} + (toCSSStyleDeclaration self) + propertyNamePtr) + >>= + maybePeek readUTFString) -cssStyleDeclarationIsPropertyImplicit :: - (CSSStyleDeclarationClass self) => self -> String -> IO Bool -cssStyleDeclarationIsPropertyImplicit self propertyName - = toBool <$> - (withUTFString propertyName $ - \ propertyNamePtr -> - {# call webkit_dom_css_style_declaration_is_property_implicit #} - (toCSSStyleDeclaration self) - propertyNamePtr) +isPropertyImplicit :: + (MonadIO m, CSSStyleDeclarationClass self, GlibString string) => + self -> string -> m Bool +isPropertyImplicit self propertyName + = liftIO + (toBool <$> + (withUTFString propertyName $ + \ propertyNamePtr -> + {# call webkit_dom_css_style_declaration_is_property_implicit #} + (toCSSStyleDeclaration self) + propertyNamePtr)) -cssStyleDeclarationSetCssText :: - (CSSStyleDeclarationClass self) => self -> String -> IO () -cssStyleDeclarationSetCssText self val - = propagateGError $ - \ errorPtr_ -> - withUTFString val $ - \ valPtr -> - {# call webkit_dom_css_style_declaration_set_css_text #} - (toCSSStyleDeclaration self) - valPtr - errorPtr_ +setCssText :: + (MonadIO m, CSSStyleDeclarationClass self, GlibString string) => + self -> (Maybe string) -> m () +setCssText self val + = liftIO + (propagateGError $ + \ errorPtr_ -> + maybeWith withUTFString val $ + \ valPtr -> + {# call webkit_dom_css_style_declaration_set_css_text #} + (toCSSStyleDeclaration self) + valPtr + errorPtr_) -cssStyleDeclarationGetCssText :: - (CSSStyleDeclarationClass self) => self -> IO String -cssStyleDeclarationGetCssText self - = ({# call webkit_dom_css_style_declaration_get_css_text #} - (toCSSStyleDeclaration self)) - >>= - readUTFString +getCssText :: + (MonadIO m, CSSStyleDeclarationClass self, GlibString string) => + self -> m (Maybe string) +getCssText self + = liftIO + (({# call webkit_dom_css_style_declaration_get_css_text #} + (toCSSStyleDeclaration self)) + >>= + maybePeek readUTFString) -cssStyleDeclarationGetLength :: - (CSSStyleDeclarationClass self) => self -> IO Word -cssStyleDeclarationGetLength self - = fromIntegral <$> - ({# call webkit_dom_css_style_declaration_get_length #} - (toCSSStyleDeclaration self)) +getLength :: + (MonadIO m, CSSStyleDeclarationClass self) => self -> m Word +getLength self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_css_style_declaration_get_length #} + (toCSSStyleDeclaration self))) -cssStyleDeclarationGetParentRule :: - (CSSStyleDeclarationClass self) => self -> IO (Maybe CSSRule) -cssStyleDeclarationGetParentRule self - = maybeNull (makeNewGObject mkCSSRule) - ({# call webkit_dom_css_style_declaration_get_parent_rule #} - (toCSSStyleDeclaration self)) +getParentRule :: + (MonadIO m, CSSStyleDeclarationClass self) => + self -> m (Maybe CSSRule) +getParentRule self + = liftIO + (maybeNull (makeNewGObject mkCSSRule) + ({# call webkit_dom_css_style_declaration_get_parent_rule #} + (toCSSStyleDeclaration self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/CSSStyleSheet.chs b/Graphics/UI/Gtk/WebKit/DOM/CSSStyleSheet.chs --- a/Graphics/UI/Gtk/WebKit/DOM/CSSStyleSheet.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/CSSStyleSheet.chs @@ -1,86 +1,111 @@ -module Graphics.UI.Gtk.WebKit.DOM.CSSStyleSheet - (cssStyleSheetInsertRule, cssStyleSheetDeleteRule, - cssStyleSheetAddRule, cssStyleSheetRemoveRule, - cssStyleSheetGetOwnerRule, cssStyleSheetGetCssRules, - cssStyleSheetGetRules, CSSStyleSheet, CSSStyleSheetClass, - castToCSSStyleSheet, gTypeCSSStyleSheet, toCSSStyleSheet) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.CSSStyleSheet( +insertRule, +deleteRule, +addRule, +removeRule, +getOwnerRule, +getCssRules, +getRules, +CSSStyleSheet, +castToCSSStyleSheet, +gTypeCSSStyleSheet, +CSSStyleSheetClass, +toCSSStyleSheet, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -cssStyleSheetInsertRule :: - (CSSStyleSheetClass self) => self -> String -> Word -> IO Word -cssStyleSheetInsertRule self rule index - = fromIntegral <$> +insertRule :: + (MonadIO m, CSSStyleSheetClass self, GlibString string) => + self -> string -> Word -> m Word +insertRule self rule index + = liftIO + (fromIntegral <$> + (propagateGError $ + \ errorPtr_ -> + withUTFString rule $ + \ rulePtr -> + {# call webkit_dom_css_style_sheet_insert_rule #} + (toCSSStyleSheet self) + rulePtr + (fromIntegral index) + errorPtr_)) + +deleteRule :: + (MonadIO m, CSSStyleSheetClass self) => self -> Word -> m () +deleteRule self index + = liftIO (propagateGError $ \ errorPtr_ -> - withUTFString rule $ - \ rulePtr -> - {# call webkit_dom_css_style_sheet_insert_rule #} - (toCSSStyleSheet self) - rulePtr + {# call webkit_dom_css_style_sheet_delete_rule #} + (toCSSStyleSheet self) (fromIntegral index) errorPtr_) -cssStyleSheetDeleteRule :: - (CSSStyleSheetClass self) => self -> Word -> IO () -cssStyleSheetDeleteRule self index - = propagateGError $ - \ errorPtr_ -> - {# call webkit_dom_css_style_sheet_delete_rule #} - (toCSSStyleSheet self) - (fromIntegral index) - errorPtr_ +addRule :: + (MonadIO m, CSSStyleSheetClass self, GlibString string) => + self -> string -> string -> Word -> m Int +addRule self selector style index + = liftIO + (fromIntegral <$> + (propagateGError $ + \ errorPtr_ -> + withUTFString style $ + \ stylePtr -> + withUTFString selector $ + \ selectorPtr -> + {# call webkit_dom_css_style_sheet_add_rule #} + (toCSSStyleSheet self) + selectorPtr + stylePtr + (fromIntegral index) + errorPtr_)) -cssStyleSheetAddRule :: - (CSSStyleSheetClass self) => - self -> String -> String -> Word -> IO Int -cssStyleSheetAddRule self selector style index - = fromIntegral <$> +removeRule :: + (MonadIO m, CSSStyleSheetClass self) => self -> Word -> m () +removeRule self index + = liftIO (propagateGError $ \ errorPtr_ -> - withUTFString style $ - \ stylePtr -> - withUTFString selector $ - \ selectorPtr -> - {# call webkit_dom_css_style_sheet_add_rule #} - (toCSSStyleSheet self) - selectorPtr - stylePtr + {# call webkit_dom_css_style_sheet_remove_rule #} + (toCSSStyleSheet self) (fromIntegral index) errorPtr_) -cssStyleSheetRemoveRule :: - (CSSStyleSheetClass self) => self -> Word -> IO () -cssStyleSheetRemoveRule self index - = propagateGError $ - \ errorPtr_ -> - {# call webkit_dom_css_style_sheet_remove_rule #} - (toCSSStyleSheet self) - (fromIntegral index) - errorPtr_ - -cssStyleSheetGetOwnerRule :: - (CSSStyleSheetClass self) => self -> IO (Maybe CSSRule) -cssStyleSheetGetOwnerRule self - = maybeNull (makeNewGObject mkCSSRule) - ({# call webkit_dom_css_style_sheet_get_owner_rule #} - (toCSSStyleSheet self)) +getOwnerRule :: + (MonadIO m, CSSStyleSheetClass self) => self -> m (Maybe CSSRule) +getOwnerRule self + = liftIO + (maybeNull (makeNewGObject mkCSSRule) + ({# call webkit_dom_css_style_sheet_get_owner_rule #} + (toCSSStyleSheet self))) -cssStyleSheetGetCssRules :: - (CSSStyleSheetClass self) => self -> IO (Maybe CSSRuleList) -cssStyleSheetGetCssRules self - = maybeNull (makeNewGObject mkCSSRuleList) - ({# call webkit_dom_css_style_sheet_get_css_rules #} - (toCSSStyleSheet self)) +getCssRules :: + (MonadIO m, CSSStyleSheetClass self) => + self -> m (Maybe CSSRuleList) +getCssRules self + = liftIO + (maybeNull (makeNewGObject mkCSSRuleList) + ({# call webkit_dom_css_style_sheet_get_css_rules #} + (toCSSStyleSheet self))) -cssStyleSheetGetRules :: - (CSSStyleSheetClass self) => self -> IO (Maybe CSSRuleList) -cssStyleSheetGetRules self - = maybeNull (makeNewGObject mkCSSRuleList) - ({# call webkit_dom_css_style_sheet_get_rules #} - (toCSSStyleSheet self)) +getRules :: + (MonadIO m, CSSStyleSheetClass self) => + self -> m (Maybe CSSRuleList) +getRules self + = liftIO + (maybeNull (makeNewGObject mkCSSRuleList) + ({# call webkit_dom_css_style_sheet_get_rules #} + (toCSSStyleSheet self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/CSSValue.chs b/Graphics/UI/Gtk/WebKit/DOM/CSSValue.chs --- a/Graphics/UI/Gtk/WebKit/DOM/CSSValue.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/CSSValue.chs @@ -1,38 +1,62 @@ -module Graphics.UI.Gtk.WebKit.DOM.CSSValue - (cCSS_INHERIT, cCSS_PRIMITIVE_VALUE, cCSS_VALUE_LIST, cCSS_CUSTOM, - cssValueSetCssText, cssValueGetCssText, cssValueGetCssValueType, - CSSValue, CSSValueClass, castToCSSValue, gTypeCSSValue, toCSSValue) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.CSSValue( +pattern CSS_INHERIT, +pattern CSS_PRIMITIVE_VALUE, +pattern CSS_VALUE_LIST, +pattern CSS_CUSTOM, +setCssText, +getCssText, +getCssValueType, +CSSValue, +castToCSSValue, +gTypeCSSValue, +CSSValueClass, +toCSSValue, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM -cCSS_INHERIT = 0 -cCSS_PRIMITIVE_VALUE = 1 -cCSS_VALUE_LIST = 2 -cCSS_CUSTOM = 3 +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + +pattern CSS_INHERIT = 0 +pattern CSS_PRIMITIVE_VALUE = 1 +pattern CSS_VALUE_LIST = 2 +pattern CSS_CUSTOM = 3 -cssValueSetCssText :: - (CSSValueClass self) => self -> String -> IO () -cssValueSetCssText self val - = propagateGError $ - \ errorPtr_ -> - withUTFString val $ - \ valPtr -> - {# call webkit_dom_css_value_set_css_text #} (toCSSValue self) - valPtr - errorPtr_ +setCssText :: + (MonadIO m, CSSValueClass self, GlibString string) => + self -> (Maybe string) -> m () +setCssText self val + = liftIO + (propagateGError $ + \ errorPtr_ -> + maybeWith withUTFString val $ + \ valPtr -> + {# call webkit_dom_css_value_set_css_text #} (toCSSValue self) + valPtr + errorPtr_) -cssValueGetCssText :: (CSSValueClass self) => self -> IO String -cssValueGetCssText self - = ({# call webkit_dom_css_value_get_css_text #} (toCSSValue self)) - >>= - readUTFString +getCssText :: + (MonadIO m, CSSValueClass self, GlibString string) => + self -> m (Maybe string) +getCssText self + = liftIO + (({# call webkit_dom_css_value_get_css_text #} (toCSSValue self)) + >>= + maybePeek readUTFString) -cssValueGetCssValueType :: (CSSValueClass self) => self -> IO Word -cssValueGetCssValueType self - = fromIntegral <$> - ({# call webkit_dom_css_value_get_css_value_type #} - (toCSSValue self)) +getCssValueType :: + (MonadIO m, CSSValueClass self) => self -> m Word +getCssValueType self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_css_value_get_css_value_type #} + (toCSSValue self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/CharacterData.chs b/Graphics/UI/Gtk/WebKit/DOM/CharacterData.chs --- a/Graphics/UI/Gtk/WebKit/DOM/CharacterData.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/CharacterData.chs @@ -1,105 +1,133 @@ -module Graphics.UI.Gtk.WebKit.DOM.CharacterData - (characterDataSubstringData, characterDataAppendData, - characterDataInsertData, characterDataDeleteData, - characterDataReplaceData, characterDataSetData, - characterDataGetData, characterDataGetLength, - CharacterData, CharacterDataClass, - castToCharacterData, gTypeCharacterData, toCharacterData) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.CharacterData( +substringData, +appendData, +insertData, +deleteData, +replaceData, +setData, +getData, +getLength, +CharacterData, +castToCharacterData, +gTypeCharacterData, +CharacterDataClass, +toCharacterData, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM - -characterDataSubstringData :: - (CharacterDataClass self) => self -> Word -> Word -> IO String -characterDataSubstringData self offset length - = (propagateGError $ - \ errorPtr_ -> - {# call webkit_dom_character_data_substring_data #} - (toCharacterData self) - (fromIntegral offset) - (fromIntegral length) - errorPtr_) - >>= - readUTFString - -characterDataAppendData :: - (CharacterDataClass self) => self -> String -> IO () -characterDataAppendData self data' - = propagateGError $ - \ errorPtr_ -> - withUTFString data' $ - \ dataPtr -> - {# call webkit_dom_character_data_append_data #} - (toCharacterData self) - dataPtr - errorPtr_ +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -characterDataInsertData :: - (CharacterDataClass self) => self -> Word -> String -> IO () -characterDataInsertData self offset data' - = propagateGError $ - \ errorPtr_ -> - withUTFString data' $ - \ dataPtr -> - {# call webkit_dom_character_data_insert_data #} +substringData :: + (MonadIO m, CharacterDataClass self, GlibString string) => + self -> Word -> Word -> m (Maybe string) +substringData self offset length + = liftIO + ((propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_character_data_substring_data #} (toCharacterData self) (fromIntegral offset) - dataPtr - errorPtr_ + (fromIntegral length) + errorPtr_) + >>= + maybePeek readUTFString) -characterDataDeleteData :: - (CharacterDataClass self) => self -> Word -> Word -> IO () -characterDataDeleteData self offset length - = propagateGError $ - \ errorPtr_ -> - {# call webkit_dom_character_data_delete_data #} - (toCharacterData self) - (fromIntegral offset) - (fromIntegral length) - errorPtr_ +appendData :: + (MonadIO m, CharacterDataClass self, GlibString string) => + self -> string -> m () +appendData self data' + = liftIO + (propagateGError $ + \ errorPtr_ -> + withUTFString data' $ + \ dataPtr -> + {# call webkit_dom_character_data_append_data #} + (toCharacterData self) + dataPtr + errorPtr_) -characterDataReplaceData :: - (CharacterDataClass self) => - self -> Word -> Word -> String -> IO () -characterDataReplaceData self offset length data' - = propagateGError $ - \ errorPtr_ -> - withUTFString data' $ - \ dataPtr -> - {# call webkit_dom_character_data_replace_data #} - (toCharacterData self) - (fromIntegral offset) - (fromIntegral length) - dataPtr - errorPtr_ +insertData :: + (MonadIO m, CharacterDataClass self, GlibString string) => + self -> Word -> string -> m () +insertData self offset data' + = liftIO + (propagateGError $ + \ errorPtr_ -> + withUTFString data' $ + \ dataPtr -> + {# call webkit_dom_character_data_insert_data #} + (toCharacterData self) + (fromIntegral offset) + dataPtr + errorPtr_) -characterDataSetData :: - (CharacterDataClass self) => self -> String -> IO () -characterDataSetData self val - = propagateGError $ - \ errorPtr_ -> - withUTFString val $ - \ valPtr -> - {# call webkit_dom_character_data_set_data #} - (toCharacterData self) - valPtr - errorPtr_ +deleteData :: + (MonadIO m, CharacterDataClass self) => + self -> Word -> Word -> m () +deleteData self offset length + = liftIO + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_character_data_delete_data #} + (toCharacterData self) + (fromIntegral offset) + (fromIntegral length) + errorPtr_) -characterDataGetData :: - (CharacterDataClass self) => self -> IO String -characterDataGetData self - = ({# call webkit_dom_character_data_get_data #} - (toCharacterData self)) - >>= - readUTFString +replaceData :: + (MonadIO m, CharacterDataClass self, GlibString string) => + self -> Word -> Word -> string -> m () +replaceData self offset length data' + = liftIO + (propagateGError $ + \ errorPtr_ -> + withUTFString data' $ + \ dataPtr -> + {# call webkit_dom_character_data_replace_data #} + (toCharacterData self) + (fromIntegral offset) + (fromIntegral length) + dataPtr + errorPtr_) -characterDataGetLength :: - (CharacterDataClass self) => self -> IO Word -characterDataGetLength self - = fromIntegral <$> - ({# call webkit_dom_character_data_get_length #} - (toCharacterData self)) +setData :: + (MonadIO m, CharacterDataClass self, GlibString string) => + self -> (Maybe string) -> m () +setData self val + = liftIO + (propagateGError $ + \ errorPtr_ -> + maybeWith withUTFString val $ + \ valPtr -> + {# call webkit_dom_character_data_set_data #} + (toCharacterData self) + valPtr + errorPtr_) + +getData :: + (MonadIO m, CharacterDataClass self, GlibString string) => + self -> m (Maybe string) +getData self + = liftIO + (({# call webkit_dom_character_data_get_data #} + (toCharacterData self)) + >>= + maybePeek readUTFString) + +getLength :: (MonadIO m, CharacterDataClass self) => self -> m Word +getLength self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_character_data_get_length #} + (toCharacterData self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/Console.chs b/Graphics/UI/Gtk/WebKit/DOM/Console.chs deleted file mode 100644 --- a/Graphics/UI/Gtk/WebKit/DOM/Console.chs +++ /dev/null @@ -1,20 +0,0 @@ -module Graphics.UI.Gtk.WebKit.DOM.Console - (consoleTime, consoleGroupEnd, Console, ConsoleClass, - castToConsole, gTypeConsole, toConsole) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} -import System.Glib.GError -import Graphics.UI.Gtk.WebKit.DOM.EventM - -consoleTime :: (ConsoleClass self) => self -> String -> IO () -consoleTime self title - = withUTFString title $ - \ titlePtr -> - {# call webkit_dom_console_time #} (toConsole self) titlePtr - -consoleGroupEnd :: (ConsoleClass self) => self -> IO () -consoleGroupEnd self - = {# call webkit_dom_console_group_end #} (toConsole self) diff --git a/Graphics/UI/Gtk/WebKit/DOM/Css.chs b/Graphics/UI/Gtk/WebKit/DOM/Css.chs deleted file mode 100644 --- a/Graphics/UI/Gtk/WebKit/DOM/Css.chs +++ /dev/null @@ -1,7 +0,0 @@ -module Graphics.UI.Gtk.WebKit.DOM.Css (CSSRule, CSSRuleClass) where - -data CSSRule = CSSRule - -class CSSRuleClass a - -instance CSSRuleClass CSSRule diff --git a/Graphics/UI/Gtk/WebKit/DOM/DOMApplicationCache.chs b/Graphics/UI/Gtk/WebKit/DOM/DOMApplicationCache.chs deleted file mode 100644 --- a/Graphics/UI/Gtk/WebKit/DOM/DOMApplicationCache.chs +++ /dev/null @@ -1,107 +0,0 @@ -module Graphics.UI.Gtk.WebKit.DOM.DOMApplicationCache - (domApplicationCacheUpdate, domApplicationCacheSwapCache, - domApplicationCacheAbort, domApplicationCacheDispatchEvent, - cUNCACHED, cIDLE, cCHECKING, cDOWNLOADING, cUPDATEREADY, cOBSOLETE, - domApplicationCacheGetStatus, domApplicationCacheOnchecking, - domApplicationCacheOnerror, domApplicationCacheOnnoupdate, - domApplicationCacheOndownloading, domApplicationCacheOnprogress, - domApplicationCacheOnupdateready, domApplicationCacheOncached, - domApplicationCacheOnobsolete, DOMApplicationCache, - DOMApplicationCacheClass, castToDOMApplicationCache, - gTypeDOMApplicationCache, toDOMApplicationCache) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} -import System.Glib.GError -import Graphics.UI.Gtk.WebKit.DOM.EventM - -domApplicationCacheUpdate :: - (DOMApplicationCacheClass self) => self -> IO () -domApplicationCacheUpdate self - = propagateGError $ - \ errorPtr_ -> - {# call webkit_dom_dom_application_cache_update #} - (toDOMApplicationCache self) - errorPtr_ - -domApplicationCacheSwapCache :: - (DOMApplicationCacheClass self) => self -> IO () -domApplicationCacheSwapCache self - = propagateGError $ - \ errorPtr_ -> - {# call webkit_dom_dom_application_cache_swap_cache #} - (toDOMApplicationCache self) - errorPtr_ - -domApplicationCacheAbort :: - (DOMApplicationCacheClass self) => self -> IO () -domApplicationCacheAbort self - = {# call webkit_dom_dom_application_cache_abort #} - (toDOMApplicationCache self) - -domApplicationCacheDispatchEvent :: - (DOMApplicationCacheClass self, EventClass evt) => - self -> Maybe evt -> IO Bool -domApplicationCacheDispatchEvent self evt - = toBool <$> - (propagateGError $ - \ errorPtr_ -> - {# call webkit_dom_dom_application_cache_dispatch_event #} - (toDOMApplicationCache self) - (maybe (Event nullForeignPtr) toEvent evt) - errorPtr_) -cUNCACHED = 0 -cIDLE = 1 -cCHECKING = 2 -cDOWNLOADING = 3 -cUPDATEREADY = 4 -cOBSOLETE = 5 - -domApplicationCacheGetStatus :: - (DOMApplicationCacheClass self) => self -> IO Word -domApplicationCacheGetStatus self - = fromIntegral <$> - ({# call webkit_dom_dom_application_cache_get_status #} - (toDOMApplicationCache self)) - -domApplicationCacheOnchecking :: - (DOMApplicationCacheClass self) => - Signal self (EventM UIEvent self ()) -domApplicationCacheOnchecking = (connect "checking") - -domApplicationCacheOnerror :: - (DOMApplicationCacheClass self) => - Signal self (EventM UIEvent self ()) -domApplicationCacheOnerror = (connect "error") - -domApplicationCacheOnnoupdate :: - (DOMApplicationCacheClass self) => - Signal self (EventM UIEvent self ()) -domApplicationCacheOnnoupdate = (connect "noupdate") - -domApplicationCacheOndownloading :: - (DOMApplicationCacheClass self) => - Signal self (EventM UIEvent self ()) -domApplicationCacheOndownloading = (connect "downloading") - -domApplicationCacheOnprogress :: - (DOMApplicationCacheClass self) => - Signal self (EventM UIEvent self ()) -domApplicationCacheOnprogress = (connect "progress") - -domApplicationCacheOnupdateready :: - (DOMApplicationCacheClass self) => - Signal self (EventM UIEvent self ()) -domApplicationCacheOnupdateready = (connect "updateready") - -domApplicationCacheOncached :: - (DOMApplicationCacheClass self) => - Signal self (EventM UIEvent self ()) -domApplicationCacheOncached = (connect "cached") - -domApplicationCacheOnobsolete :: - (DOMApplicationCacheClass self) => - Signal self (EventM UIEvent self ()) -domApplicationCacheOnobsolete = (connect "obsolete") diff --git a/Graphics/UI/Gtk/WebKit/DOM/DOMImplementation.chs b/Graphics/UI/Gtk/WebKit/DOM/DOMImplementation.chs --- a/Graphics/UI/Gtk/WebKit/DOM/DOMImplementation.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/DOMImplementation.chs @@ -1,96 +1,116 @@ -module Graphics.UI.Gtk.WebKit.DOM.DOMImplementation - (domImplementationHasFeature, domImplementationCreateDocumentType, - domImplementationCreateDocument, - domImplementationCreateCSSStyleSheet, - domImplementationCreateHTMLDocument, DOMImplementation, - DOMImplementationClass, castToDOMImplementation, - gTypeDOMImplementation, toDOMImplementation) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.DOMImplementation( +hasFeature, +createDocumentType, +createDocument, +createCSSStyleSheet, +createHTMLDocument, +DOMImplementation, +castToDOMImplementation, +gTypeDOMImplementation, +DOMImplementationClass, +toDOMImplementation, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -domImplementationHasFeature :: - (DOMImplementationClass self) => - self -> String -> String -> IO Bool -domImplementationHasFeature self feature version - = toBool <$> - (withUTFString version $ - \ versionPtr -> - withUTFString feature $ - \ featurePtr -> - {# call webkit_dom_dom_implementation_has_feature #} - (toDOMImplementation self) - featurePtr - versionPtr) +hasFeature :: + (MonadIO m, DOMImplementationClass self, GlibString string) => + self -> string -> (Maybe string) -> m Bool +hasFeature self feature version + = liftIO + (toBool <$> + (maybeWith withUTFString version $ + \ versionPtr -> + withUTFString feature $ + \ featurePtr -> + {# call webkit_dom_dom_implementation_has_feature #} + (toDOMImplementation self) + featurePtr + versionPtr)) -domImplementationCreateDocumentType :: - (DOMImplementationClass self) => - self -> String -> String -> String -> IO (Maybe DocumentType) -domImplementationCreateDocumentType self qualifiedName publicId - systemId - = maybeNull (makeNewGObject mkDocumentType) - (propagateGError $ - \ errorPtr_ -> - withUTFString systemId $ - \ systemIdPtr -> - withUTFString publicId $ - \ publicIdPtr -> - withUTFString qualifiedName $ - \ qualifiedNamePtr -> - {# call webkit_dom_dom_implementation_create_document_type #} - (toDOMImplementation self) - qualifiedNamePtr - publicIdPtr - systemIdPtr - errorPtr_) +createDocumentType :: + (MonadIO m, DOMImplementationClass self, GlibString string) => + self -> + (Maybe string) -> + (Maybe string) -> (Maybe string) -> m (Maybe DocumentType) +createDocumentType self qualifiedName publicId systemId + = liftIO + (maybeNull (makeNewGObject mkDocumentType) + (propagateGError $ + \ errorPtr_ -> + maybeWith withUTFString systemId $ + \ systemIdPtr -> + maybeWith withUTFString publicId $ + \ publicIdPtr -> + maybeWith withUTFString qualifiedName $ + \ qualifiedNamePtr -> + {# call webkit_dom_dom_implementation_create_document_type #} + (toDOMImplementation self) + qualifiedNamePtr + publicIdPtr + systemIdPtr + errorPtr_)) -domImplementationCreateDocument :: - (DOMImplementationClass self, DocumentTypeClass doctype) => - self -> String -> String -> Maybe doctype -> IO (Maybe Document) -domImplementationCreateDocument self namespaceURI qualifiedName - doctype - = maybeNull (makeNewGObject mkDocument) - (propagateGError $ - \ errorPtr_ -> - withUTFString qualifiedName $ - \ qualifiedNamePtr -> - withUTFString namespaceURI $ - \ namespaceURIPtr -> - {# call webkit_dom_dom_implementation_create_document #} - (toDOMImplementation self) - namespaceURIPtr - qualifiedNamePtr - (maybe (DocumentType nullForeignPtr) toDocumentType doctype) - errorPtr_) +createDocument :: + (MonadIO m, DOMImplementationClass self, DocumentTypeClass doctype, + GlibString string) => + self -> + (Maybe string) -> + (Maybe string) -> Maybe doctype -> m (Maybe Document) +createDocument self namespaceURI qualifiedName doctype + = liftIO + (maybeNull (makeNewGObject mkDocument) + (propagateGError $ + \ errorPtr_ -> + maybeWith withUTFString qualifiedName $ + \ qualifiedNamePtr -> + maybeWith withUTFString namespaceURI $ + \ namespaceURIPtr -> + {# call webkit_dom_dom_implementation_create_document #} + (toDOMImplementation self) + namespaceURIPtr + qualifiedNamePtr + (maybe (DocumentType nullForeignPtr) toDocumentType doctype) + errorPtr_)) -domImplementationCreateCSSStyleSheet :: - (DOMImplementationClass self) => - self -> String -> String -> IO (Maybe CSSStyleSheet) -domImplementationCreateCSSStyleSheet self title media - = maybeNull (makeNewGObject mkCSSStyleSheet) - (propagateGError $ - \ errorPtr_ -> - withUTFString media $ - \ mediaPtr -> - withUTFString title $ - \ titlePtr -> - {# call webkit_dom_dom_implementation_create_css_style_sheet #} - (toDOMImplementation self) - titlePtr - mediaPtr - errorPtr_) +createCSSStyleSheet :: + (MonadIO m, DOMImplementationClass self, GlibString string) => + self -> string -> string -> m (Maybe CSSStyleSheet) +createCSSStyleSheet self title media + = liftIO + (maybeNull (makeNewGObject mkCSSStyleSheet) + (propagateGError $ + \ errorPtr_ -> + withUTFString media $ + \ mediaPtr -> + withUTFString title $ + \ titlePtr -> + {# call webkit_dom_dom_implementation_create_css_style_sheet #} + (toDOMImplementation self) + titlePtr + mediaPtr + errorPtr_)) -domImplementationCreateHTMLDocument :: - (DOMImplementationClass self) => - self -> String -> IO (Maybe HTMLDocument) -domImplementationCreateHTMLDocument self title - = maybeNull (makeNewGObject mkHTMLDocument) - (withUTFString title $ - \ titlePtr -> - {# call webkit_dom_dom_implementation_create_html_document #} - (toDOMImplementation self) - titlePtr) +createHTMLDocument :: + (MonadIO m, DOMImplementationClass self, GlibString string) => + self -> string -> m (Maybe HTMLDocument) +createHTMLDocument self title + = liftIO + (maybeNull (makeNewGObject mkHTMLDocument) + (withUTFString title $ + \ titlePtr -> + {# call webkit_dom_dom_implementation_create_html_document #} + (toDOMImplementation self) + titlePtr)) diff --git a/Graphics/UI/Gtk/WebKit/DOM/DOMMimeType.chs b/Graphics/UI/Gtk/WebKit/DOM/DOMMimeType.chs deleted file mode 100644 --- a/Graphics/UI/Gtk/WebKit/DOM/DOMMimeType.chs +++ /dev/null @@ -1,34 +0,0 @@ -module Graphics.UI.Gtk.WebKit.DOM.DOMMimeType - (domMimeTypeGetSuffixes, domMimeTypeGetDescription, - domMimeTypeGetEnabledPlugin, DOMMimeType, DOMMimeTypeClass, - castToDOMMimeType, gTypeDOMMimeType, toDOMMimeType) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} -import System.Glib.GError -import Graphics.UI.Gtk.WebKit.DOM.EventM - -domMimeTypeGetSuffixes :: - (DOMMimeTypeClass self) => self -> IO String -domMimeTypeGetSuffixes self - = ({# call webkit_dom_dom_mime_type_get_suffixes #} - (toDOMMimeType self)) - >>= - readUTFString - -domMimeTypeGetDescription :: - (DOMMimeTypeClass self) => self -> IO String -domMimeTypeGetDescription self - = ({# call webkit_dom_dom_mime_type_get_description #} - (toDOMMimeType self)) - >>= - readUTFString - -domMimeTypeGetEnabledPlugin :: - (DOMMimeTypeClass self) => self -> IO (Maybe DOMPlugin) -domMimeTypeGetEnabledPlugin self - = maybeNull (makeNewGObject mkDOMPlugin) - ({# call webkit_dom_dom_mime_type_get_enabled_plugin #} - (toDOMMimeType self)) diff --git a/Graphics/UI/Gtk/WebKit/DOM/DOMMimeTypeArray.chs b/Graphics/UI/Gtk/WebKit/DOM/DOMMimeTypeArray.chs deleted file mode 100644 --- a/Graphics/UI/Gtk/WebKit/DOM/DOMMimeTypeArray.chs +++ /dev/null @@ -1,38 +0,0 @@ -module Graphics.UI.Gtk.WebKit.DOM.DOMMimeTypeArray - (domMimeTypeArrayItem, domMimeTypeArrayNamedItem, - domMimeTypeArrayGetLength, DOMMimeTypeArray, DOMMimeTypeArrayClass, - castToDOMMimeTypeArray, gTypeDOMMimeTypeArray, toDOMMimeTypeArray) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} -import System.Glib.GError -import Graphics.UI.Gtk.WebKit.DOM.EventM - -domMimeTypeArrayItem :: - (DOMMimeTypeArrayClass self) => - self -> Word -> IO (Maybe DOMMimeType) -domMimeTypeArrayItem self index - = maybeNull (makeNewGObject mkDOMMimeType) - ({# call webkit_dom_dom_mime_type_array_item #} - (toDOMMimeTypeArray self) - (fromIntegral index)) - -domMimeTypeArrayNamedItem :: - (DOMMimeTypeArrayClass self) => - self -> String -> IO (Maybe DOMMimeType) -domMimeTypeArrayNamedItem self name - = maybeNull (makeNewGObject mkDOMMimeType) - (withUTFString name $ - \ namePtr -> - {# call webkit_dom_dom_mime_type_array_named_item #} - (toDOMMimeTypeArray self) - namePtr) - -domMimeTypeArrayGetLength :: - (DOMMimeTypeArrayClass self) => self -> IO Word -domMimeTypeArrayGetLength self - = fromIntegral <$> - ({# call webkit_dom_dom_mime_type_array_get_length #} - (toDOMMimeTypeArray self)) diff --git a/Graphics/UI/Gtk/WebKit/DOM/DOMNamedFlowCollection.chs b/Graphics/UI/Gtk/WebKit/DOM/DOMNamedFlowCollection.chs --- a/Graphics/UI/Gtk/WebKit/DOM/DOMNamedFlowCollection.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/DOMNamedFlowCollection.chs @@ -1,45 +1,58 @@ -module Graphics.UI.Gtk.WebKit.DOM.DOMNamedFlowCollection - ( +module Graphics.UI.Gtk.WebKit.DOM.DOMNamedFlowCollection( #if WEBKIT_CHECK_VERSION(2,2,2) - domNamedFlowCollectionItem, domNamedFlowCollectionNamedItem, - domNamedFlowCollectionGetLength, DOMNamedFlowCollection, - DOMNamedFlowCollectionClass, castToDOMNamedFlowCollection, - gTypeDOMNamedFlowCollection, toDOMNamedFlowCollection +item, +namedItem, +getLength, +DOMNamedFlowCollection, +castToDOMNamedFlowCollection, +gTypeDOMNamedFlowCollection, +DOMNamedFlowCollectionClass, +toDOMNamedFlowCollection, #endif - ) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +) where +#if WEBKIT_CHECK_VERSION(2,2,2) +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -#if WEBKIT_CHECK_VERSION(2,2,2) -domNamedFlowCollectionItem :: - (DOMNamedFlowCollectionClass self) => - self -> Word -> IO (Maybe WebKitNamedFlow) -domNamedFlowCollectionItem self index - = maybeNull (makeNewGObject mkWebKitNamedFlow) - ({# call webkit_dom_dom_named_flow_collection_item #} - (toDOMNamedFlowCollection self) - (fromIntegral index)) +item :: + (MonadIO m, DOMNamedFlowCollectionClass self) => + self -> Word -> m (Maybe WebKitNamedFlow) +item self index + = liftIO + (maybeNull (makeNewGObject mkWebKitNamedFlow) + ({# call webkit_dom_dom_named_flow_collection_item #} + (toDOMNamedFlowCollection self) + (fromIntegral index))) -domNamedFlowCollectionNamedItem :: - (DOMNamedFlowCollectionClass self) => - self -> String -> IO (Maybe WebKitNamedFlow) -domNamedFlowCollectionNamedItem self name - = maybeNull (makeNewGObject mkWebKitNamedFlow) - (withUTFString name $ - \ namePtr -> - {# call webkit_dom_dom_named_flow_collection_named_item #} - (toDOMNamedFlowCollection self) - namePtr) +namedItem :: + (MonadIO m, DOMNamedFlowCollectionClass self, GlibString string) => + self -> string -> m (Maybe WebKitNamedFlow) +namedItem self name + = liftIO + (maybeNull (makeNewGObject mkWebKitNamedFlow) + (withUTFString name $ + \ namePtr -> + {# call webkit_dom_dom_named_flow_collection_named_item #} + (toDOMNamedFlowCollection self) + namePtr)) -domNamedFlowCollectionGetLength :: - (DOMNamedFlowCollectionClass self) => self -> IO Word -domNamedFlowCollectionGetLength self - = fromIntegral <$> - ({# call webkit_dom_dom_named_flow_collection_get_length #} - (toDOMNamedFlowCollection self)) +getLength :: + (MonadIO m, DOMNamedFlowCollectionClass self) => self -> m Word +getLength self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_dom_named_flow_collection_get_length #} + (toDOMNamedFlowCollection self))) #endif diff --git a/Graphics/UI/Gtk/WebKit/DOM/DOMPlugin.chs b/Graphics/UI/Gtk/WebKit/DOM/DOMPlugin.chs deleted file mode 100644 --- a/Graphics/UI/Gtk/WebKit/DOM/DOMPlugin.chs +++ /dev/null @@ -1,54 +0,0 @@ -module Graphics.UI.Gtk.WebKit.DOM.DOMPlugin - (domPluginItem, domPluginNamedItem, domPluginGetName, - domPluginGetFilename, domPluginGetDescription, domPluginGetLength, - DOMPlugin, DOMPluginClass, castToDOMPlugin, gTypeDOMPlugin, - toDOMPlugin) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} -import System.Glib.GError -import Graphics.UI.Gtk.WebKit.DOM.EventM - -domPluginItem :: - (DOMPluginClass self) => self -> Word -> IO (Maybe DOMMimeType) -domPluginItem self index - = maybeNull (makeNewGObject mkDOMMimeType) - ({# call webkit_dom_dom_plugin_item #} (toDOMPlugin self) - (fromIntegral index)) - -domPluginNamedItem :: - (DOMPluginClass self) => self -> String -> IO (Maybe DOMMimeType) -domPluginNamedItem self name - = maybeNull (makeNewGObject mkDOMMimeType) - (withUTFString name $ - \ namePtr -> - {# call webkit_dom_dom_plugin_named_item #} (toDOMPlugin self) - namePtr) - -domPluginGetName :: (DOMPluginClass self) => self -> IO String -domPluginGetName self - = ({# call webkit_dom_dom_plugin_get_name #} (toDOMPlugin self)) - >>= - readUTFString - -domPluginGetFilename :: (DOMPluginClass self) => self -> IO String -domPluginGetFilename self - = ({# call webkit_dom_dom_plugin_get_filename #} - (toDOMPlugin self)) - >>= - readUTFString - -domPluginGetDescription :: - (DOMPluginClass self) => self -> IO String -domPluginGetDescription self - = ({# call webkit_dom_dom_plugin_get_description #} - (toDOMPlugin self)) - >>= - readUTFString - -domPluginGetLength :: (DOMPluginClass self) => self -> IO Word -domPluginGetLength self - = fromIntegral <$> - ({# call webkit_dom_dom_plugin_get_length #} (toDOMPlugin self)) diff --git a/Graphics/UI/Gtk/WebKit/DOM/DOMPluginArray.chs b/Graphics/UI/Gtk/WebKit/DOM/DOMPluginArray.chs deleted file mode 100644 --- a/Graphics/UI/Gtk/WebKit/DOM/DOMPluginArray.chs +++ /dev/null @@ -1,45 +0,0 @@ -module Graphics.UI.Gtk.WebKit.DOM.DOMPluginArray - (domPluginArrayItem, domPluginArrayNamedItem, - domPluginArrayRefresh, domPluginArrayGetLength, DOMPluginArray, - DOMPluginArrayClass, castToDOMPluginArray, gTypeDOMPluginArray, - toDOMPluginArray) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} -import System.Glib.GError -import Graphics.UI.Gtk.WebKit.DOM.EventM - -domPluginArrayItem :: - (DOMPluginArrayClass self) => self -> Word -> IO (Maybe DOMPlugin) -domPluginArrayItem self index - = maybeNull (makeNewGObject mkDOMPlugin) - ({# call webkit_dom_dom_plugin_array_item #} - (toDOMPluginArray self) - (fromIntegral index)) - -domPluginArrayNamedItem :: - (DOMPluginArrayClass self) => - self -> String -> IO (Maybe DOMPlugin) -domPluginArrayNamedItem self name - = maybeNull (makeNewGObject mkDOMPlugin) - (withUTFString name $ - \ namePtr -> - {# call webkit_dom_dom_plugin_array_named_item #} - (toDOMPluginArray self) - namePtr) - -domPluginArrayRefresh :: - (DOMPluginArrayClass self) => self -> Bool -> IO () -domPluginArrayRefresh self reload - = {# call webkit_dom_dom_plugin_array_refresh #} - (toDOMPluginArray self) - (fromBool reload) - -domPluginArrayGetLength :: - (DOMPluginArrayClass self) => self -> IO Word -domPluginArrayGetLength self - = fromIntegral <$> - ({# call webkit_dom_dom_plugin_array_get_length #} - (toDOMPluginArray self)) diff --git a/Graphics/UI/Gtk/WebKit/DOM/DOMSecurityPolicy.chs b/Graphics/UI/Gtk/WebKit/DOM/DOMSecurityPolicy.chs deleted file mode 100644 --- a/Graphics/UI/Gtk/WebKit/DOM/DOMSecurityPolicy.chs +++ /dev/null @@ -1,166 +0,0 @@ -module Graphics.UI.Gtk.WebKit.DOM.DOMSecurityPolicy ( -#if WEBKIT_CHECK_VERSION(1,10,0) -#if !WEBKIT_CHECK_VERSION(2,0,0) - domSecurityPolicyIsActive, -#endif - domSecurityPolicyAllowsConnectionTo, - domSecurityPolicyAllowsFontFrom, domSecurityPolicyAllowsFormAction, - domSecurityPolicyAllowsFrameFrom, domSecurityPolicyAllowsImageFrom, - domSecurityPolicyAllowsMediaFrom, - domSecurityPolicyAllowsObjectFrom, - domSecurityPolicyAllowsPluginType, - domSecurityPolicyAllowsScriptFrom, - domSecurityPolicyAllowsStyleFrom, domSecurityPolicyAllowsEval, - domSecurityPolicyAllowsInlineScript, - domSecurityPolicyAllowsInlineStyle, domSecurityPolicyGetReportURIs, - DOMSecurityPolicy, DOMSecurityPolicyClass, castToDOMSecurityPolicy, - gTypeDOMSecurityPolicy, toDOMSecurityPolicy -#endif -) where - -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} -import System.Glib.GError -import Graphics.UI.Gtk.WebKit.DOM.EventM - -#if WEBKIT_CHECK_VERSION(1,10,0) -#if !WEBKIT_CHECK_VERSION(2,0,0) -domSecurityPolicyIsActive :: (DOMSecurityPolicyClass self) => self -> IO Bool -domSecurityPolicyIsActive self = toBool <$> - ({# call webkit_dom_dom_security_policy_is_active #} (toDOMSecurityPolicy self)) -#endif - -domSecurityPolicyAllowsConnectionTo :: (DOMSecurityPolicyClass self) => self -> String -> IO Bool -domSecurityPolicyAllowsConnectionTo self url = toBool <$> - (withUTFString url $ \urlPtr -> - {# call webkit_dom_dom_security_policy_allows_connection_to #} (toDOMSecurityPolicy self) urlPtr) - -domSecurityPolicyAllowsFontFrom :: - (DOMSecurityPolicyClass self) => self -> String -> IO Bool -domSecurityPolicyAllowsFontFrom self url - = toBool <$> - (withUTFString url $ - \ urlPtr -> - {# call webkit_dom_dom_security_policy_allows_font_from #} - (toDOMSecurityPolicy self) - urlPtr) - -domSecurityPolicyAllowsFormAction :: - (DOMSecurityPolicyClass self) => self -> String -> IO Bool -domSecurityPolicyAllowsFormAction self url - = toBool <$> - (withUTFString url $ - \ urlPtr -> - {# call webkit_dom_dom_security_policy_allows_form_action #} - (toDOMSecurityPolicy self) - urlPtr) - -domSecurityPolicyAllowsFrameFrom :: - (DOMSecurityPolicyClass self) => self -> String -> IO Bool -domSecurityPolicyAllowsFrameFrom self url - = toBool <$> - (withUTFString url $ - \ urlPtr -> - {# call webkit_dom_dom_security_policy_allows_frame_from #} - (toDOMSecurityPolicy self) - urlPtr) - -domSecurityPolicyAllowsImageFrom :: - (DOMSecurityPolicyClass self) => self -> String -> IO Bool -domSecurityPolicyAllowsImageFrom self url - = toBool <$> - (withUTFString url $ - \ urlPtr -> - {# call webkit_dom_dom_security_policy_allows_image_from #} - (toDOMSecurityPolicy self) - urlPtr) - -domSecurityPolicyAllowsMediaFrom :: - (DOMSecurityPolicyClass self) => self -> String -> IO Bool -domSecurityPolicyAllowsMediaFrom self url - = toBool <$> - (withUTFString url $ - \ urlPtr -> - {# call webkit_dom_dom_security_policy_allows_media_from #} - (toDOMSecurityPolicy self) - urlPtr) - -domSecurityPolicyAllowsObjectFrom :: - (DOMSecurityPolicyClass self) => self -> String -> IO Bool -domSecurityPolicyAllowsObjectFrom self url - = toBool <$> - (withUTFString url $ - \ urlPtr -> - {# call webkit_dom_dom_security_policy_allows_object_from #} - (toDOMSecurityPolicy self) - urlPtr) - -domSecurityPolicyAllowsPluginType :: - (DOMSecurityPolicyClass self) => self -> String -> IO Bool -domSecurityPolicyAllowsPluginType self type' - = toBool <$> - (withUTFString type' $ - \ typePtr -> - {# call webkit_dom_dom_security_policy_allows_plugin_type #} - (toDOMSecurityPolicy self) - typePtr) - -domSecurityPolicyAllowsScriptFrom :: - (DOMSecurityPolicyClass self) => self -> String -> IO Bool -domSecurityPolicyAllowsScriptFrom self url - = toBool <$> - (withUTFString url $ - \ urlPtr -> - {# call webkit_dom_dom_security_policy_allows_script_from #} - (toDOMSecurityPolicy self) - urlPtr) - -domSecurityPolicyAllowsStyleFrom :: - (DOMSecurityPolicyClass self) => self -> String -> IO Bool -domSecurityPolicyAllowsStyleFrom self url - = toBool <$> - (withUTFString url $ - \ urlPtr -> - {# call webkit_dom_dom_security_policy_allows_style_from #} - (toDOMSecurityPolicy self) - urlPtr) - - -domSecurityPolicyAllowsEval :: (DOMSecurityPolicyClass self) => self -> IO Bool -domSecurityPolicyAllowsEval self = toBool <$> -#if WEBKIT_CHECK_VERSION(2,0,0) - ({# call webkit_dom_dom_security_policy_get_allows_eval #} -#else - ({# call webkit_dom_dom_security_policy_allows_eval #} -#endif - (toDOMSecurityPolicy self)) - - -domSecurityPolicyAllowsInlineScript :: (DOMSecurityPolicyClass self) => self -> IO Bool -domSecurityPolicyAllowsInlineScript self = toBool <$> -#if WEBKIT_CHECK_VERSION(2,0,0) - ({# call webkit_dom_dom_security_policy_get_allows_inline_script #} -#else - ({# call webkit_dom_dom_security_policy_allows_inline_script #} -#endif - (toDOMSecurityPolicy self)) - - -domSecurityPolicyAllowsInlineStyle :: (DOMSecurityPolicyClass self) => self -> IO Bool -domSecurityPolicyAllowsInlineStyle self = toBool <$> -#if WEBKIT_CHECK_VERSION(2,0,0) - ({# call webkit_dom_dom_security_policy_get_allows_inline_style #} -#else - ({# call webkit_dom_dom_security_policy_allows_inline_style #} -#endif - (toDOMSecurityPolicy self)) - -domSecurityPolicyGetReportURIs :: - (DOMSecurityPolicyClass self) => self -> IO (Maybe DOMStringList) -domSecurityPolicyGetReportURIs self - = maybeNull (makeNewGObject mkDOMStringList) - ({# call webkit_dom_dom_security_policy_get_report_ur_is #} - (toDOMSecurityPolicy self)) -#endif diff --git a/Graphics/UI/Gtk/WebKit/DOM/DOMSelection.chs b/Graphics/UI/Gtk/WebKit/DOM/DOMSelection.chs deleted file mode 100644 --- a/Graphics/UI/Gtk/WebKit/DOM/DOMSelection.chs +++ /dev/null @@ -1,231 +0,0 @@ -module Graphics.UI.Gtk.WebKit.DOM.DOMSelection - (domSelectionCollapse, domSelectionCollapseToEnd, - domSelectionCollapseToStart, domSelectionDeleteFromDocument, - domSelectionContainsNode, domSelectionSelectAllChildren, - domSelectionExtend, domSelectionGetRangeAt, - domSelectionRemoveAllRanges, domSelectionAddRange, - domSelectionModify, domSelectionSetBaseAndExtent, - domSelectionSetPosition, domSelectionEmpty, - domSelectionGetAnchorNode, domSelectionGetAnchorOffset, - domSelectionGetFocusNode, domSelectionGetFocusOffset, - domSelectionGetIsCollapsed, domSelectionGetRangeCount, - domSelectionGetBaseNode, domSelectionGetBaseOffset, - domSelectionGetExtentNode, domSelectionGetExtentOffset, - DOMSelection, DOMSelectionClass, castToDOMSelection, - gTypeDOMSelection, toDOMSelection) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} -import System.Glib.GError -import Graphics.UI.Gtk.WebKit.DOM.EventM - -domSelectionCollapse :: - (DOMSelectionClass self, NodeClass node) => - self -> Maybe node -> Int -> IO () -domSelectionCollapse self node index - = propagateGError $ - \ errorPtr_ -> - {# call webkit_dom_dom_selection_collapse #} (toDOMSelection self) - (maybe (Node nullForeignPtr) toNode node) - (fromIntegral index) - errorPtr_ - -domSelectionCollapseToEnd :: - (DOMSelectionClass self) => self -> IO () -domSelectionCollapseToEnd self - = propagateGError $ - \ errorPtr_ -> - {# call webkit_dom_dom_selection_collapse_to_end #} - (toDOMSelection self) - errorPtr_ - -domSelectionCollapseToStart :: - (DOMSelectionClass self) => self -> IO () -domSelectionCollapseToStart self - = propagateGError $ - \ errorPtr_ -> - {# call webkit_dom_dom_selection_collapse_to_start #} - (toDOMSelection self) - errorPtr_ - -domSelectionDeleteFromDocument :: - (DOMSelectionClass self) => self -> IO () -domSelectionDeleteFromDocument self - = {# call webkit_dom_dom_selection_delete_from_document #} - (toDOMSelection self) - -domSelectionContainsNode :: - (DOMSelectionClass self, NodeClass node) => - self -> Maybe node -> Bool -> IO Bool -domSelectionContainsNode self node allowPartial - = toBool <$> - ({# call webkit_dom_dom_selection_contains_node #} - (toDOMSelection self) - (maybe (Node nullForeignPtr) toNode node) - (fromBool allowPartial)) - -domSelectionSelectAllChildren :: - (DOMSelectionClass self, NodeClass node) => - self -> Maybe node -> IO () -domSelectionSelectAllChildren self node - = propagateGError $ - \ errorPtr_ -> - {# call webkit_dom_dom_selection_select_all_children #} - (toDOMSelection self) - (maybe (Node nullForeignPtr) toNode node) - errorPtr_ - -domSelectionExtend :: - (DOMSelectionClass self, NodeClass node) => - self -> Maybe node -> Int -> IO () -domSelectionExtend self node offset - = propagateGError $ - \ errorPtr_ -> - {# call webkit_dom_dom_selection_extend #} (toDOMSelection self) - (maybe (Node nullForeignPtr) toNode node) - (fromIntegral offset) - errorPtr_ - -domSelectionGetRangeAt :: - (DOMSelectionClass self) => self -> Int -> IO (Maybe DOMRange) -domSelectionGetRangeAt self index - = maybeNull (makeNewGObject mkDOMRange) - (propagateGError $ - \ errorPtr_ -> - {# call webkit_dom_dom_selection_get_range_at #} - (toDOMSelection self) - (fromIntegral index) - errorPtr_) - -domSelectionRemoveAllRanges :: - (DOMSelectionClass self) => self -> IO () -domSelectionRemoveAllRanges self - = {# call webkit_dom_dom_selection_remove_all_ranges #} - (toDOMSelection self) - -domSelectionAddRange :: - (DOMSelectionClass self, DOMRangeClass range) => - self -> Maybe range -> IO () -domSelectionAddRange self range - = {# call webkit_dom_dom_selection_add_range #} - (toDOMSelection self) - (maybe (DOMRange nullForeignPtr) toDOMRange range) - -domSelectionModify :: - (DOMSelectionClass self) => - self -> String -> String -> String -> IO () -domSelectionModify self alter direction granularity - = withUTFString granularity $ - \ granularityPtr -> - withUTFString direction $ - \ directionPtr -> - withUTFString alter $ - \ alterPtr -> - {# call webkit_dom_dom_selection_modify #} (toDOMSelection self) - alterPtr - directionPtr - granularityPtr - -domSelectionSetBaseAndExtent :: - (DOMSelectionClass self, NodeClass baseNode, - NodeClass extentNode) => - self -> Maybe baseNode -> Int -> Maybe extentNode -> Int -> IO () -domSelectionSetBaseAndExtent self baseNode baseOffset extentNode - extentOffset - = propagateGError $ - \ errorPtr_ -> - {# call webkit_dom_dom_selection_set_base_and_extent #} - (toDOMSelection self) - (maybe (Node nullForeignPtr) toNode baseNode) - (fromIntegral baseOffset) - (maybe (Node nullForeignPtr) toNode extentNode) - (fromIntegral extentOffset) - errorPtr_ - -domSelectionSetPosition :: - (DOMSelectionClass self, NodeClass node) => - self -> Maybe node -> Int -> IO () -domSelectionSetPosition self node offset - = propagateGError $ - \ errorPtr_ -> - {# call webkit_dom_dom_selection_set_position #} - (toDOMSelection self) - (maybe (Node nullForeignPtr) toNode node) - (fromIntegral offset) - errorPtr_ - -domSelectionEmpty :: (DOMSelectionClass self) => self -> IO () -domSelectionEmpty self - = {# call webkit_dom_dom_selection_empty #} (toDOMSelection self) - -domSelectionGetAnchorNode :: - (DOMSelectionClass self) => self -> IO (Maybe Node) -domSelectionGetAnchorNode self - = maybeNull (makeNewGObject mkNode) - ({# call webkit_dom_dom_selection_get_anchor_node #} - (toDOMSelection self)) - -domSelectionGetAnchorOffset :: - (DOMSelectionClass self) => self -> IO Int -domSelectionGetAnchorOffset self - = fromIntegral <$> - ({# call webkit_dom_dom_selection_get_anchor_offset #} - (toDOMSelection self)) - -domSelectionGetFocusNode :: - (DOMSelectionClass self) => self -> IO (Maybe Node) -domSelectionGetFocusNode self - = maybeNull (makeNewGObject mkNode) - ({# call webkit_dom_dom_selection_get_focus_node #} - (toDOMSelection self)) - -domSelectionGetFocusOffset :: - (DOMSelectionClass self) => self -> IO Int -domSelectionGetFocusOffset self - = fromIntegral <$> - ({# call webkit_dom_dom_selection_get_focus_offset #} - (toDOMSelection self)) - -domSelectionGetIsCollapsed :: - (DOMSelectionClass self) => self -> IO Bool -domSelectionGetIsCollapsed self - = toBool <$> - ({# call webkit_dom_dom_selection_get_is_collapsed #} - (toDOMSelection self)) - -domSelectionGetRangeCount :: - (DOMSelectionClass self) => self -> IO Int -domSelectionGetRangeCount self - = fromIntegral <$> - ({# call webkit_dom_dom_selection_get_range_count #} - (toDOMSelection self)) - -domSelectionGetBaseNode :: - (DOMSelectionClass self) => self -> IO (Maybe Node) -domSelectionGetBaseNode self - = maybeNull (makeNewGObject mkNode) - ({# call webkit_dom_dom_selection_get_base_node #} - (toDOMSelection self)) - -domSelectionGetBaseOffset :: - (DOMSelectionClass self) => self -> IO Int -domSelectionGetBaseOffset self - = fromIntegral <$> - ({# call webkit_dom_dom_selection_get_base_offset #} - (toDOMSelection self)) - -domSelectionGetExtentNode :: - (DOMSelectionClass self) => self -> IO (Maybe Node) -domSelectionGetExtentNode self - = maybeNull (makeNewGObject mkNode) - ({# call webkit_dom_dom_selection_get_extent_node #} - (toDOMSelection self)) - -domSelectionGetExtentOffset :: - (DOMSelectionClass self) => self -> IO Int -domSelectionGetExtentOffset self - = fromIntegral <$> - ({# call webkit_dom_dom_selection_get_extent_offset #} - (toDOMSelection self)) diff --git a/Graphics/UI/Gtk/WebKit/DOM/DOMSettableTokenList.chs b/Graphics/UI/Gtk/WebKit/DOM/DOMSettableTokenList.chs --- a/Graphics/UI/Gtk/WebKit/DOM/DOMSettableTokenList.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/DOMSettableTokenList.chs @@ -1,29 +1,44 @@ -module Graphics.UI.Gtk.WebKit.DOM.DOMSettableTokenList - (domSettableTokenListSetValue, domSettableTokenListGetValue, - DOMSettableTokenList, DOMSettableTokenListClass, - castToDOMSettableTokenList, gTypeDOMSettableTokenList, - toDOMSettableTokenList) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.DOMSettableTokenList( +setValue, +getValue, +DOMSettableTokenList, +castToDOMSettableTokenList, +gTypeDOMSettableTokenList, +DOMSettableTokenListClass, +toDOMSettableTokenList, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -domSettableTokenListSetValue :: - (DOMSettableTokenListClass self) => self -> String -> IO () -domSettableTokenListSetValue self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_dom_settable_token_list_set_value #} - (toDOMSettableTokenList self) - valPtr +setValue :: + (MonadIO m, DOMSettableTokenListClass self, GlibString string) => + self -> string -> m () +setValue self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_dom_settable_token_list_set_value #} + (toDOMSettableTokenList self) + valPtr) -domSettableTokenListGetValue :: - (DOMSettableTokenListClass self) => self -> IO String -domSettableTokenListGetValue self - = ({# call webkit_dom_dom_settable_token_list_get_value #} - (toDOMSettableTokenList self)) - >>= - readUTFString +getValue :: + (MonadIO m, DOMSettableTokenListClass self, GlibString string) => + self -> m string +getValue self + = liftIO + (({# call webkit_dom_dom_settable_token_list_get_value #} + (toDOMSettableTokenList self)) + >>= + readUTFString) diff --git a/Graphics/UI/Gtk/WebKit/DOM/DOMStringList.chs b/Graphics/UI/Gtk/WebKit/DOM/DOMStringList.chs --- a/Graphics/UI/Gtk/WebKit/DOM/DOMStringList.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/DOMStringList.chs @@ -1,37 +1,53 @@ -module Graphics.UI.Gtk.WebKit.DOM.DOMStringList - (domStringListItem, domStringListContains, domStringListGetLength, - DOMStringList, DOMStringListClass, castToDOMStringList, - gTypeDOMStringList, toDOMStringList) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.DOMStringList( +item, +contains, +getLength, +DOMStringList, +castToDOMStringList, +gTypeDOMStringList, +DOMStringListClass, +toDOMStringList, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -domStringListItem :: - (DOMStringListClass self) => self -> Word -> IO String -domStringListItem self index - = ({# call webkit_dom_dom_string_list_item #} - (toDOMStringList self) - (fromIntegral index)) - >>= - readUTFString +item :: + (MonadIO m, DOMStringListClass self, GlibString string) => + self -> Word -> m (Maybe string) +item self index + = liftIO + (({# call webkit_dom_dom_string_list_item #} (toDOMStringList self) + (fromIntegral index)) + >>= + maybePeek readUTFString) -domStringListContains :: - (DOMStringListClass self) => self -> String -> IO Bool -domStringListContains self string - = toBool <$> - (withUTFString string $ - \ stringPtr -> - {# call webkit_dom_dom_string_list_contains #} - (toDOMStringList self) - stringPtr) +contains :: + (MonadIO m, DOMStringListClass self, GlibString string) => + self -> string -> m Bool +contains self string + = liftIO + (toBool <$> + (withUTFString string $ + \ stringPtr -> + {# call webkit_dom_dom_string_list_contains #} + (toDOMStringList self) + stringPtr)) -domStringListGetLength :: - (DOMStringListClass self) => self -> IO Word -domStringListGetLength self - = fromIntegral <$> - ({# call webkit_dom_dom_string_list_get_length #} - (toDOMStringList self)) +getLength :: (MonadIO m, DOMStringListClass self) => self -> m Word +getLength self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_dom_string_list_get_length #} + (toDOMStringList self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/DOMTokenList.chs b/Graphics/UI/Gtk/WebKit/DOM/DOMTokenList.chs --- a/Graphics/UI/Gtk/WebKit/DOM/DOMTokenList.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/DOMTokenList.chs @@ -1,79 +1,103 @@ -module Graphics.UI.Gtk.WebKit.DOM.DOMTokenList - (domTokenListItem, domTokenListContains, domTokenListAdd, - domTokenListRemove, domTokenListToggle, domTokenListGetLength, - DOMTokenList, DOMTokenListClass, castToDOMTokenList, - gTypeDOMTokenList, toDOMTokenList) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.DOMTokenList( +item, +contains, +add, +remove, +#if WEBKIT_CHECK_VERSION(2,2,2) +toggle, +#endif +getLength, +DOMTokenList, +castToDOMTokenList, +gTypeDOMTokenList, +DOMTokenListClass, +toDOMTokenList, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM - -domTokenListItem :: - (DOMTokenListClass self) => self -> Word -> IO String -domTokenListItem self index - = ({# call webkit_dom_dom_token_list_item #} (toDOMTokenList self) - (fromIntegral index)) - >>= - readUTFString +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums -domTokenListContains :: - (DOMTokenListClass self) => self -> String -> IO Bool -domTokenListContains self token - = toBool <$> + +item :: + (MonadIO m, DOMTokenListClass self, GlibString string) => + self -> Word -> m (Maybe string) +item self index + = liftIO + (({# call webkit_dom_dom_token_list_item #} (toDOMTokenList self) + (fromIntegral index)) + >>= + maybePeek readUTFString) + +contains :: + (MonadIO m, DOMTokenListClass self, GlibString string) => + self -> string -> m Bool +contains self token + = liftIO + (toBool <$> + (propagateGError $ + \ errorPtr_ -> + withUTFString token $ + \ tokenPtr -> + {# call webkit_dom_dom_token_list_contains #} (toDOMTokenList self) + tokenPtr + errorPtr_)) + +add :: + (MonadIO m, DOMTokenListClass self, GlibString string) => + self -> string -> m () +add self tokens + = liftIO (propagateGError $ \ errorPtr_ -> - withUTFString token $ - \ tokenPtr -> - {# call webkit_dom_dom_token_list_contains #} (toDOMTokenList self) - tokenPtr + withUTFString tokens $ + \ tokensPtr -> + {# call webkit_dom_dom_token_list_add #} (toDOMTokenList self) + tokensPtr errorPtr_) - -domTokenListAdd :: - (DOMTokenListClass self) => self -> String -> IO () -domTokenListAdd self token - = propagateGError $ - \ errorPtr_ -> - withUTFString token $ - \ tokenPtr -> - {# call webkit_dom_dom_token_list_add #} (toDOMTokenList self) - tokenPtr - errorPtr_ - -domTokenListRemove :: - (DOMTokenListClass self) => self -> String -> IO () -domTokenListRemove self token - = propagateGError $ - \ errorPtr_ -> - withUTFString token $ - \ tokenPtr -> - {# call webkit_dom_dom_token_list_remove #} (toDOMTokenList self) - tokenPtr - errorPtr_ - -#if WEBKIT_CHECK_VERSION(2,0,0) -domTokenListToggle :: (DOMTokenListClass self) => self -> String -> Bool -> IO Bool -domTokenListToggle self token force = toBool <$> (propagateGError $ \errorPtr_ -> withUTFString token $ \tokenPtr -> - {# call webkit_dom_dom_token_list_toggle #} (toDOMTokenList self) tokenPtr (fromBool force) errorPtr_) -#else -domTokenListToggle :: - (DOMTokenListClass self) => self -> String -> IO Bool -domTokenListToggle self token - = toBool <$> + +remove :: + (MonadIO m, DOMTokenListClass self, GlibString string) => + self -> string -> m () +remove self tokens + = liftIO (propagateGError $ \ errorPtr_ -> - withUTFString token $ - \ tokenPtr -> - {# call webkit_dom_dom_token_list_toggle #} (toDOMTokenList self) - tokenPtr + withUTFString tokens $ + \ tokensPtr -> + {# call webkit_dom_dom_token_list_remove #} (toDOMTokenList self) + tokensPtr errorPtr_) -#endif -domTokenListGetLength :: - (DOMTokenListClass self) => self -> IO Word -domTokenListGetLength self - = fromIntegral <$> - ({# call webkit_dom_dom_token_list_get_length #} - (toDOMTokenList self)) +#if WEBKIT_CHECK_VERSION(2,2,2) +toggle :: + (MonadIO m, DOMTokenListClass self, GlibString string) => + self -> string -> Bool -> m Bool +toggle self token force + = liftIO + (toBool <$> + (propagateGError $ + \ errorPtr_ -> + withUTFString token $ + \ tokenPtr -> + {# call webkit_dom_dom_token_list_toggle #} (toDOMTokenList self) + tokenPtr + (fromBool force) + errorPtr_)) +#endif + +getLength :: (MonadIO m, DOMTokenListClass self) => self -> m Word +getLength self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_dom_token_list_get_length #} + (toDOMTokenList self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/DOMWindow.chs b/Graphics/UI/Gtk/WebKit/DOM/DOMWindow.chs deleted file mode 100644 --- a/Graphics/UI/Gtk/WebKit/DOM/DOMWindow.chs +++ /dev/null @@ -1,915 +0,0 @@ -module Graphics.UI.Gtk.WebKit.DOM.DOMWindow - (domWindowGetSelection, domWindowBlur, domWindowPrint, - domWindowStop, domWindowAlert, domWindowConfirm, domWindowPrompt, - domWindowFind, domWindowScrollBy, domWindowScrollTo, - domWindowScroll, domWindowMoveBy, domWindowMoveTo, - domWindowResizeBy, domWindowResizeTo, domWindowMatchMedia, - domWindowGetComputedStyle, - domWindowWebkitConvertPointFromPageToNode, - domWindowWebkitConvertPointFromNodeToPage, domWindowClearTimeout, - domWindowClearInterval, domWindowAtob, domWindowBtoa, - domWindowDispatchEvent, domWindowCaptureEvents, - domWindowReleaseEvents, domWindowGetScreen, domWindowGetHistory, -#if WEBKIT_CHECK_VERSION(2,2,2) - domWindowGetLocationbar, domWindowGetMenubar, - domWindowGetPersonalbar, domWindowGetScrollbars, - domWindowGetStatusbar, domWindowGetToolbar, -#endif - domWindowGetNavigator, - domWindowGetClientInformation, domWindowGetFrameElement, - domWindowGetOffscreenBuffering, domWindowGetOuterHeight, - domWindowGetOuterWidth, domWindowGetInnerHeight, - domWindowGetInnerWidth, domWindowGetScreenX, domWindowGetScreenY, - domWindowGetScreenLeft, domWindowGetScreenTop, domWindowGetScrollX, - domWindowGetScrollY, domWindowGetPageXOffset, - domWindowGetPageYOffset, domWindowGetClosed, domWindowGetLength, - domWindowSetName, domWindowGetName, domWindowSetStatus, - domWindowGetStatus, domWindowSetDefaultStatus, - domWindowGetDefaultStatus, domWindowGetSelf, domWindowGetWindow, - domWindowGetFrames, domWindowGetOpener, domWindowGetParent, - domWindowGetTop, domWindowGetDocument, domWindowGetStyleMedia, - domWindowGetDevicePixelRatio, domWindowGetApplicationCache, - domWindowGetSessionStorage, domWindowGetLocalStorage, - domWindowGetConsole, -#if WEBKIT_CHECK_VERSION(2,2,2) - domWindowGetCSS, -#endif - domWindowOnabort, domWindowOnbeforeunload, - domWindowOnblur, domWindowOncanplay, domWindowOncanplaythrough, - domWindowOnchange, domWindowOnclick, domWindowOncontextmenu, - domWindowOndblclick, domWindowOndrag, domWindowOndragend, - domWindowOndragenter, domWindowOndragleave, domWindowOndragover, - domWindowOndragstart, domWindowOndrop, domWindowOndurationchange, - domWindowOnemptied, domWindowOnended, domWindowOnerror, - domWindowOnfocus, domWindowOnhashchange, domWindowOninput, - domWindowOninvalid, domWindowOnkeydown, domWindowOnkeypress, - domWindowOnkeyup, domWindowOnload, domWindowOnloadeddata, - domWindowOnloadedmetadata, domWindowOnloadstart, - domWindowOnmessage, domWindowOnmousedown, -#if WEBKIT_CHECK_VERSION(2,2,2) - domWindowOnmouseenter, domWindowOnmouseleave, -#endif - domWindowOnmousemove, - domWindowOnmouseout, domWindowOnmouseover, domWindowOnmouseup, - domWindowOnmousewheel, domWindowOnoffline, domWindowOnonline, - domWindowOnpagehide, domWindowOnpageshow, domWindowOnpause, - domWindowOnplay, domWindowOnplaying, domWindowOnpopstate, - domWindowOnprogress, domWindowOnratechange, domWindowOnresize, - domWindowOnscroll, domWindowOnseeked, domWindowOnseeking, - domWindowOnselect, domWindowOnstalled, domWindowOnstorage, - domWindowOnsubmit, domWindowOnsuspend, domWindowOntimeupdate, - domWindowOnunload, domWindowOnvolumechange, domWindowOnwaiting, - domWindowOnreset, domWindowOnsearch, domWindowOnwebkitanimationend, - domWindowOnwebkitanimationiteration, - domWindowOnwebkitanimationstart, domWindowOnwebkittransitionend, -#if WEBKIT_CHECK_VERSION(2,2,2) - domWindowOntransitionend, -#endif - domWindowOntouchstart, domWindowOntouchmove, domWindowOntouchend, - domWindowOntouchcancel, domWindowOndevicemotion, - domWindowOndeviceorientation, -#if WEBKIT_CHECK_VERSION(1,10,0) - domWindowOnwebkitdeviceproximity, -#endif - DOMWindow, DOMWindowClass, castToDOMWindow, gTypeDOMWindow, toDOMWindow) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} -import System.Glib.GError -import Graphics.UI.Gtk.WebKit.DOM.EventM - -domWindowGetSelection :: - (DOMWindowClass self) => self -> IO (Maybe DOMSelection) -domWindowGetSelection self - = maybeNull (makeNewGObject mkDOMSelection) - ({# call webkit_dom_dom_window_get_selection #} (toDOMWindow self)) - -domWindowBlur :: (DOMWindowClass self) => self -> IO () -domWindowBlur self - = {# call webkit_dom_dom_window_blur #} (toDOMWindow self) - -domWindowPrint :: (DOMWindowClass self) => self -> IO () -domWindowPrint self - = {# call webkit_dom_dom_window_print #} (toDOMWindow self) - -domWindowStop :: (DOMWindowClass self) => self -> IO () -domWindowStop self - = {# call webkit_dom_dom_window_stop #} (toDOMWindow self) - -domWindowAlert :: (DOMWindowClass self) => self -> String -> IO () -domWindowAlert self message - = withUTFString message $ - \ messagePtr -> - {# call webkit_dom_dom_window_alert #} (toDOMWindow self) - messagePtr - -domWindowConfirm :: - (DOMWindowClass self) => self -> String -> IO Bool -domWindowConfirm self message - = toBool <$> - (withUTFString message $ - \ messagePtr -> - {# call webkit_dom_dom_window_confirm #} (toDOMWindow self) - messagePtr) - -domWindowPrompt :: - (DOMWindowClass self) => self -> String -> String -> IO String -domWindowPrompt self message defaultValue - = (withUTFString defaultValue $ - \ defaultValuePtr -> - withUTFString message $ - \ messagePtr -> - {# call webkit_dom_dom_window_prompt #} (toDOMWindow self) - messagePtr - defaultValuePtr) - >>= - readUTFString - -domWindowFind :: - (DOMWindowClass self) => - self -> - String -> Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> IO Bool -domWindowFind self string caseSensitive backwards wrap wholeWord - searchInFrames showDialog - = toBool <$> - (withUTFString string $ - \ stringPtr -> - {# call webkit_dom_dom_window_find #} (toDOMWindow self) stringPtr - (fromBool caseSensitive) - (fromBool backwards) - (fromBool wrap) - (fromBool wholeWord) - (fromBool searchInFrames) - (fromBool showDialog)) - -domWindowScrollBy :: - (DOMWindowClass self) => self -> Int -> Int -> IO () -domWindowScrollBy self x y - = {# call webkit_dom_dom_window_scroll_by #} (toDOMWindow self) - (fromIntegral x) - (fromIntegral y) - -domWindowScrollTo :: - (DOMWindowClass self) => self -> Int -> Int -> IO () -domWindowScrollTo self x y - = {# call webkit_dom_dom_window_scroll_to #} (toDOMWindow self) - (fromIntegral x) - (fromIntegral y) - -domWindowScroll :: - (DOMWindowClass self) => self -> Int -> Int -> IO () -domWindowScroll self x y - = {# call webkit_dom_dom_window_scroll #} (toDOMWindow self) - (fromIntegral x) - (fromIntegral y) - -domWindowMoveBy :: - (DOMWindowClass self) => self -> Float -> Float -> IO () -domWindowMoveBy self x y - = {# call webkit_dom_dom_window_move_by #} (toDOMWindow self) - (realToFrac x) - (realToFrac y) - -domWindowMoveTo :: - (DOMWindowClass self) => self -> Float -> Float -> IO () -domWindowMoveTo self x y - = {# call webkit_dom_dom_window_move_to #} (toDOMWindow self) - (realToFrac x) - (realToFrac y) - -domWindowResizeBy :: - (DOMWindowClass self) => self -> Float -> Float -> IO () -domWindowResizeBy self x y - = {# call webkit_dom_dom_window_resize_by #} (toDOMWindow self) - (realToFrac x) - (realToFrac y) - -domWindowResizeTo :: - (DOMWindowClass self) => self -> Float -> Float -> IO () -domWindowResizeTo self width height - = {# call webkit_dom_dom_window_resize_to #} (toDOMWindow self) - (realToFrac width) - (realToFrac height) - -domWindowMatchMedia :: - (DOMWindowClass self) => - self -> String -> IO (Maybe MediaQueryList) -domWindowMatchMedia self query - = maybeNull (makeNewGObject mkMediaQueryList) - (withUTFString query $ - \ queryPtr -> - {# call webkit_dom_dom_window_match_media #} (toDOMWindow self) - queryPtr) - -domWindowGetComputedStyle :: - (DOMWindowClass self, ElementClass element) => - self -> Maybe element -> String -> IO (Maybe CSSStyleDeclaration) -domWindowGetComputedStyle self element pseudoElement - = maybeNull (makeNewGObject mkCSSStyleDeclaration) - (withUTFString pseudoElement $ - \ pseudoElementPtr -> - {# call webkit_dom_dom_window_get_computed_style #} - (toDOMWindow self) - (maybe (Element nullForeignPtr) toElement element) - pseudoElementPtr) - -domWindowWebkitConvertPointFromPageToNode :: - (DOMWindowClass self, NodeClass node, - WebKitPointClass p) => - self -> Maybe node -> Maybe p -> IO (Maybe WebKitPoint) -domWindowWebkitConvertPointFromPageToNode self node p - = maybeNull (makeNewGObject mkWebKitPoint) - ({# call - webkit_dom_dom_window_webkit_convert_point_from_page_to_node - #} - (toDOMWindow self) - (maybe (Node nullForeignPtr) toNode node) - (maybe (WebKitPoint nullForeignPtr) toWebKitPoint p)) - -domWindowWebkitConvertPointFromNodeToPage :: - (DOMWindowClass self, NodeClass node, - WebKitPointClass p) => - self -> Maybe node -> Maybe p -> IO (Maybe WebKitPoint) -domWindowWebkitConvertPointFromNodeToPage self node p - = maybeNull (makeNewGObject mkWebKitPoint) - ({# call - webkit_dom_dom_window_webkit_convert_point_from_node_to_page - #} - (toDOMWindow self) - (maybe (Node nullForeignPtr) toNode node) - (maybe (WebKitPoint nullForeignPtr) toWebKitPoint p)) - -domWindowClearTimeout :: - (DOMWindowClass self) => self -> Int -> IO () -domWindowClearTimeout self handle - = {# call webkit_dom_dom_window_clear_timeout #} (toDOMWindow self) - (fromIntegral handle) - -domWindowClearInterval :: - (DOMWindowClass self) => self -> Int -> IO () -domWindowClearInterval self handle - = {# call webkit_dom_dom_window_clear_interval #} - (toDOMWindow self) - (fromIntegral handle) - -domWindowAtob :: - (DOMWindowClass self) => self -> String -> IO String -domWindowAtob self string - = (propagateGError $ - \ errorPtr_ -> - withUTFString string $ - \ stringPtr -> - {# call webkit_dom_dom_window_atob #} (toDOMWindow self) stringPtr - errorPtr_) - >>= - readUTFString - -domWindowBtoa :: - (DOMWindowClass self) => self -> String -> IO String -domWindowBtoa self string - = (propagateGError $ - \ errorPtr_ -> - withUTFString string $ - \ stringPtr -> - {# call webkit_dom_dom_window_btoa #} (toDOMWindow self) stringPtr - errorPtr_) - >>= - readUTFString - -domWindowDispatchEvent :: - (DOMWindowClass self, EventClass evt) => - self -> Maybe evt -> IO Bool -domWindowDispatchEvent self evt - = toBool <$> - (propagateGError $ - \ errorPtr_ -> - {# call webkit_dom_dom_window_dispatch_event #} (toDOMWindow self) - (maybe (Event nullForeignPtr) toEvent evt) - errorPtr_) - -domWindowCaptureEvents :: (DOMWindowClass self) => self -> IO () -domWindowCaptureEvents self - = {# call webkit_dom_dom_window_capture_events #} - (toDOMWindow self) - -domWindowReleaseEvents :: (DOMWindowClass self) => self -> IO () -domWindowReleaseEvents self - = {# call webkit_dom_dom_window_release_events #} - (toDOMWindow self) - -domWindowGetScreen :: - (DOMWindowClass self) => self -> IO (Maybe DOMScreen) -domWindowGetScreen self - = maybeNull (makeNewGObject mkDOMScreen) - ({# call webkit_dom_dom_window_get_screen #} (toDOMWindow self)) - -domWindowGetHistory :: - (DOMWindowClass self) => self -> IO (Maybe History) -domWindowGetHistory self - = maybeNull (makeNewGObject mkHistory) - ({# call webkit_dom_dom_window_get_history #} (toDOMWindow self)) - -#if WEBKIT_CHECK_VERSION(2,2,2) -domWindowGetLocationbar :: - (DOMWindowClass self) => self -> IO (Maybe BarProp) -domWindowGetLocationbar self - = maybeNull (makeNewGObject mkBarProp) - ({# call webkit_dom_dom_window_get_locationbar #} - (toDOMWindow self)) - -domWindowGetMenubar :: - (DOMWindowClass self) => self -> IO (Maybe BarProp) -domWindowGetMenubar self - = maybeNull (makeNewGObject mkBarProp) - ({# call webkit_dom_dom_window_get_menubar #} (toDOMWindow self)) - -domWindowGetPersonalbar :: - (DOMWindowClass self) => self -> IO (Maybe BarProp) -domWindowGetPersonalbar self - = maybeNull (makeNewGObject mkBarProp) - ({# call webkit_dom_dom_window_get_personalbar #} - (toDOMWindow self)) - -domWindowGetScrollbars :: - (DOMWindowClass self) => self -> IO (Maybe BarProp) -domWindowGetScrollbars self - = maybeNull (makeNewGObject mkBarProp) - ({# call webkit_dom_dom_window_get_scrollbars #} - (toDOMWindow self)) - -domWindowGetStatusbar :: - (DOMWindowClass self) => self -> IO (Maybe BarProp) -domWindowGetStatusbar self - = maybeNull (makeNewGObject mkBarProp) - ({# call webkit_dom_dom_window_get_statusbar #} (toDOMWindow self)) - -domWindowGetToolbar :: - (DOMWindowClass self) => self -> IO (Maybe BarProp) -domWindowGetToolbar self - = maybeNull (makeNewGObject mkBarProp) - ({# call webkit_dom_dom_window_get_toolbar #} (toDOMWindow self)) -#endif - -domWindowGetNavigator :: - (DOMWindowClass self) => self -> IO (Maybe Navigator) -domWindowGetNavigator self - = maybeNull (makeNewGObject mkNavigator) - ({# call webkit_dom_dom_window_get_navigator #} (toDOMWindow self)) - -domWindowGetClientInformation :: - (DOMWindowClass self) => self -> IO (Maybe Navigator) -domWindowGetClientInformation self - = maybeNull (makeNewGObject mkNavigator) - ({# call webkit_dom_dom_window_get_client_information #} - (toDOMWindow self)) - -domWindowGetFrameElement :: - (DOMWindowClass self) => self -> IO (Maybe Element) -domWindowGetFrameElement self - = maybeNull (makeNewGObject mkElement) - ({# call webkit_dom_dom_window_get_frame_element #} - (toDOMWindow self)) - -domWindowGetOffscreenBuffering :: - (DOMWindowClass self) => self -> IO Bool -domWindowGetOffscreenBuffering self - = toBool <$> - ({# call webkit_dom_dom_window_get_offscreen_buffering #} - (toDOMWindow self)) - -domWindowGetOuterHeight :: (DOMWindowClass self) => self -> IO Int -domWindowGetOuterHeight self - = fromIntegral <$> - ({# call webkit_dom_dom_window_get_outer_height #} - (toDOMWindow self)) - -domWindowGetOuterWidth :: (DOMWindowClass self) => self -> IO Int -domWindowGetOuterWidth self - = fromIntegral <$> - ({# call webkit_dom_dom_window_get_outer_width #} - (toDOMWindow self)) - -domWindowGetInnerHeight :: (DOMWindowClass self) => self -> IO Int -domWindowGetInnerHeight self - = fromIntegral <$> - ({# call webkit_dom_dom_window_get_inner_height #} - (toDOMWindow self)) - -domWindowGetInnerWidth :: (DOMWindowClass self) => self -> IO Int -domWindowGetInnerWidth self - = fromIntegral <$> - ({# call webkit_dom_dom_window_get_inner_width #} - (toDOMWindow self)) - -domWindowGetScreenX :: (DOMWindowClass self) => self -> IO Int -domWindowGetScreenX self - = fromIntegral <$> - ({# call webkit_dom_dom_window_get_screen_x #} (toDOMWindow self)) - -domWindowGetScreenY :: (DOMWindowClass self) => self -> IO Int -domWindowGetScreenY self - = fromIntegral <$> - ({# call webkit_dom_dom_window_get_screen_y #} (toDOMWindow self)) - -domWindowGetScreenLeft :: (DOMWindowClass self) => self -> IO Int -domWindowGetScreenLeft self - = fromIntegral <$> - ({# call webkit_dom_dom_window_get_screen_left #} - (toDOMWindow self)) - -domWindowGetScreenTop :: (DOMWindowClass self) => self -> IO Int -domWindowGetScreenTop self - = fromIntegral <$> - ({# call webkit_dom_dom_window_get_screen_top #} - (toDOMWindow self)) - -domWindowGetScrollX :: (DOMWindowClass self) => self -> IO Int -domWindowGetScrollX self - = fromIntegral <$> - ({# call webkit_dom_dom_window_get_scroll_x #} (toDOMWindow self)) - -domWindowGetScrollY :: (DOMWindowClass self) => self -> IO Int -domWindowGetScrollY self - = fromIntegral <$> - ({# call webkit_dom_dom_window_get_scroll_y #} (toDOMWindow self)) - -domWindowGetPageXOffset :: (DOMWindowClass self) => self -> IO Int -domWindowGetPageXOffset self - = fromIntegral <$> - ({# call webkit_dom_dom_window_get_page_x_offset #} - (toDOMWindow self)) - -domWindowGetPageYOffset :: (DOMWindowClass self) => self -> IO Int -domWindowGetPageYOffset self - = fromIntegral <$> - ({# call webkit_dom_dom_window_get_page_y_offset #} - (toDOMWindow self)) - -domWindowGetClosed :: (DOMWindowClass self) => self -> IO Bool -domWindowGetClosed self - = toBool <$> - ({# call webkit_dom_dom_window_get_closed #} (toDOMWindow self)) - -domWindowGetLength :: (DOMWindowClass self) => self -> IO Word -domWindowGetLength self - = fromIntegral <$> - ({# call webkit_dom_dom_window_get_length #} (toDOMWindow self)) - -domWindowSetName :: - (DOMWindowClass self) => self -> String -> IO () -domWindowSetName self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_dom_window_set_name #} (toDOMWindow self) valPtr - -domWindowGetName :: (DOMWindowClass self) => self -> IO String -domWindowGetName self - = ({# call webkit_dom_dom_window_get_name #} (toDOMWindow self)) - >>= - readUTFString - -domWindowSetStatus :: - (DOMWindowClass self) => self -> String -> IO () -domWindowSetStatus self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_dom_window_set_status #} (toDOMWindow self) - valPtr - -domWindowGetStatus :: (DOMWindowClass self) => self -> IO String -domWindowGetStatus self - = ({# call webkit_dom_dom_window_get_status #} (toDOMWindow self)) - >>= - readUTFString - -domWindowSetDefaultStatus :: - (DOMWindowClass self) => self -> String -> IO () -domWindowSetDefaultStatus self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_dom_window_set_default_status #} - (toDOMWindow self) - valPtr - -domWindowGetDefaultStatus :: - (DOMWindowClass self) => self -> IO String -domWindowGetDefaultStatus self - = ({# call webkit_dom_dom_window_get_default_status #} - (toDOMWindow self)) - >>= - readUTFString - -domWindowGetSelf :: - (DOMWindowClass self) => self -> IO (Maybe DOMWindow) -domWindowGetSelf self - = maybeNull (makeNewGObject mkDOMWindow) - ({# call webkit_dom_dom_window_get_self #} (toDOMWindow self)) - -domWindowGetWindow :: - (DOMWindowClass self) => self -> IO (Maybe DOMWindow) -domWindowGetWindow self - = maybeNull (makeNewGObject mkDOMWindow) - ({# call webkit_dom_dom_window_get_window #} (toDOMWindow self)) - -domWindowGetFrames :: - (DOMWindowClass self) => self -> IO (Maybe DOMWindow) -domWindowGetFrames self - = maybeNull (makeNewGObject mkDOMWindow) - ({# call webkit_dom_dom_window_get_frames #} (toDOMWindow self)) - -domWindowGetOpener :: - (DOMWindowClass self) => self -> IO (Maybe DOMWindow) -domWindowGetOpener self - = maybeNull (makeNewGObject mkDOMWindow) - ({# call webkit_dom_dom_window_get_opener #} (toDOMWindow self)) - -domWindowGetParent :: - (DOMWindowClass self) => self -> IO (Maybe DOMWindow) -domWindowGetParent self - = maybeNull (makeNewGObject mkDOMWindow) - ({# call webkit_dom_dom_window_get_parent #} (toDOMWindow self)) - -domWindowGetTop :: - (DOMWindowClass self) => self -> IO (Maybe DOMWindow) -domWindowGetTop self - = maybeNull (makeNewGObject mkDOMWindow) - ({# call webkit_dom_dom_window_get_top #} (toDOMWindow self)) - -domWindowGetDocument :: - (DOMWindowClass self) => self -> IO (Maybe Document) -domWindowGetDocument self - = maybeNull (makeNewGObject mkDocument) - ({# call webkit_dom_dom_window_get_document #} (toDOMWindow self)) - -domWindowGetStyleMedia :: - (DOMWindowClass self) => self -> IO (Maybe StyleMedia) -domWindowGetStyleMedia self - = maybeNull (makeNewGObject mkStyleMedia) - ({# call webkit_dom_dom_window_get_style_media #} - (toDOMWindow self)) - -domWindowGetDevicePixelRatio :: - (DOMWindowClass self) => self -> IO Double -domWindowGetDevicePixelRatio self - = realToFrac <$> - ({# call webkit_dom_dom_window_get_device_pixel_ratio #} - (toDOMWindow self)) - -domWindowGetApplicationCache :: - (DOMWindowClass self) => self -> IO (Maybe DOMApplicationCache) -domWindowGetApplicationCache self - = maybeNull (makeNewGObject mkDOMApplicationCache) - ({# call webkit_dom_dom_window_get_application_cache #} - (toDOMWindow self)) - -domWindowGetSessionStorage :: - (DOMWindowClass self) => self -> IO (Maybe Storage) -domWindowGetSessionStorage self - = maybeNull (makeNewGObject mkStorage) - (propagateGError $ - \ errorPtr_ -> - {# call webkit_dom_dom_window_get_session_storage #} - (toDOMWindow self) - errorPtr_) - -domWindowGetLocalStorage :: - (DOMWindowClass self) => self -> IO (Maybe Storage) -domWindowGetLocalStorage self - = maybeNull (makeNewGObject mkStorage) - (propagateGError $ - \ errorPtr_ -> - {# call webkit_dom_dom_window_get_local_storage #} - (toDOMWindow self) - errorPtr_) - -domWindowGetConsole :: - (DOMWindowClass self) => self -> IO (Maybe Console) -domWindowGetConsole self - = maybeNull (makeNewGObject mkConsole) - ({# call webkit_dom_dom_window_get_console #} (toDOMWindow self)) - -#if WEBKIT_CHECK_VERSION(2,2,2) -domWindowGetCSS :: - (DOMWindowClass self) => self -> IO (Maybe DOMWindowCSS) -domWindowGetCSS self - = maybeNull (makeNewGObject mkDOMWindowCSS) - ({# call webkit_dom_dom_window_get_css #} (toDOMWindow self)) -#endif - -domWindowOnabort :: - (DOMWindowClass self) => Signal self (EventM UIEvent self ()) -domWindowOnabort = (connect "abort") - -domWindowOnbeforeunload :: - (DOMWindowClass self) => Signal self (EventM UIEvent self ()) -domWindowOnbeforeunload = (connect "beforeunload") - -domWindowOnblur :: - (DOMWindowClass self) => Signal self (EventM UIEvent self ()) -domWindowOnblur = (connect "blur") - -domWindowOncanplay :: - (DOMWindowClass self) => Signal self (EventM UIEvent self ()) -domWindowOncanplay = (connect "canplay") - -domWindowOncanplaythrough :: - (DOMWindowClass self) => Signal self (EventM UIEvent self ()) -domWindowOncanplaythrough = (connect "canplaythrough") - -domWindowOnchange :: - (DOMWindowClass self) => Signal self (EventM UIEvent self ()) -domWindowOnchange = (connect "change") - -domWindowOnclick :: - (DOMWindowClass self) => Signal self (EventM MouseEvent self ()) -domWindowOnclick = (connect "click") - -domWindowOncontextmenu :: - (DOMWindowClass self) => Signal self (EventM MouseEvent self ()) -domWindowOncontextmenu = (connect "contextmenu") - -domWindowOndblclick :: - (DOMWindowClass self) => Signal self (EventM MouseEvent self ()) -domWindowOndblclick = (connect "dblclick") - -domWindowOndrag :: - (DOMWindowClass self) => Signal self (EventM MouseEvent self ()) -domWindowOndrag = (connect "drag") - -domWindowOndragend :: - (DOMWindowClass self) => Signal self (EventM MouseEvent self ()) -domWindowOndragend = (connect "dragend") - -domWindowOndragenter :: - (DOMWindowClass self) => Signal self (EventM MouseEvent self ()) -domWindowOndragenter = (connect "dragenter") - -domWindowOndragleave :: - (DOMWindowClass self) => Signal self (EventM MouseEvent self ()) -domWindowOndragleave = (connect "dragleave") - -domWindowOndragover :: - (DOMWindowClass self) => Signal self (EventM MouseEvent self ()) -domWindowOndragover = (connect "dragover") - -domWindowOndragstart :: - (DOMWindowClass self) => Signal self (EventM MouseEvent self ()) -domWindowOndragstart = (connect "dragstart") - -domWindowOndrop :: - (DOMWindowClass self) => Signal self (EventM MouseEvent self ()) -domWindowOndrop = (connect "drop") - -domWindowOndurationchange :: - (DOMWindowClass self) => Signal self (EventM UIEvent self ()) -domWindowOndurationchange = (connect "durationchange") - -domWindowOnemptied :: - (DOMWindowClass self) => Signal self (EventM UIEvent self ()) -domWindowOnemptied = (connect "emptied") - -domWindowOnended :: - (DOMWindowClass self) => Signal self (EventM UIEvent self ()) -domWindowOnended = (connect "ended") - -domWindowOnerror :: - (DOMWindowClass self) => Signal self (EventM UIEvent self ()) -domWindowOnerror = (connect "error") - -domWindowOnfocus :: - (DOMWindowClass self) => Signal self (EventM UIEvent self ()) -domWindowOnfocus = (connect "focus") - -domWindowOnhashchange :: - (DOMWindowClass self) => Signal self (EventM UIEvent self ()) -domWindowOnhashchange = (connect "hashchange") - -domWindowOninput :: - (DOMWindowClass self) => Signal self (EventM UIEvent self ()) -domWindowOninput = (connect "input") - -domWindowOninvalid :: - (DOMWindowClass self) => Signal self (EventM UIEvent self ()) -domWindowOninvalid = (connect "invalid") - -domWindowOnkeydown :: - (DOMWindowClass self) => Signal self (EventM UIEvent self ()) -domWindowOnkeydown = (connect "keydown") - -domWindowOnkeypress :: - (DOMWindowClass self) => Signal self (EventM UIEvent self ()) -domWindowOnkeypress = (connect "keypress") - -domWindowOnkeyup :: - (DOMWindowClass self) => Signal self (EventM UIEvent self ()) -domWindowOnkeyup = (connect "keyup") - -domWindowOnload :: - (DOMWindowClass self) => Signal self (EventM UIEvent self ()) -domWindowOnload = (connect "load") - -domWindowOnloadeddata :: - (DOMWindowClass self) => Signal self (EventM UIEvent self ()) -domWindowOnloadeddata = (connect "loadeddata") - -domWindowOnloadedmetadata :: - (DOMWindowClass self) => Signal self (EventM UIEvent self ()) -domWindowOnloadedmetadata = (connect "loadedmetadata") - -domWindowOnloadstart :: - (DOMWindowClass self) => Signal self (EventM UIEvent self ()) -domWindowOnloadstart = (connect "loadstart") - -domWindowOnmessage :: - (DOMWindowClass self) => Signal self (EventM UIEvent self ()) -domWindowOnmessage = (connect "message") - -domWindowOnmousedown :: - (DOMWindowClass self) => Signal self (EventM MouseEvent self ()) -domWindowOnmousedown = (connect "mousedown") - -#if WEBKIT_CHECK_VERSION(2,2,2) -domWindowOnmouseenter :: - (DOMWindowClass self) => Signal self (EventM UIEvent self ()) -domWindowOnmouseenter = (connect "mouseenter") - -domWindowOnmouseleave :: - (DOMWindowClass self) => Signal self (EventM UIEvent self ()) -domWindowOnmouseleave = (connect "mouseleave") -#endif - -domWindowOnmousemove :: - (DOMWindowClass self) => Signal self (EventM MouseEvent self ()) -domWindowOnmousemove = (connect "mousemove") - -domWindowOnmouseout :: - (DOMWindowClass self) => Signal self (EventM MouseEvent self ()) -domWindowOnmouseout = (connect "mouseout") - -domWindowOnmouseover :: - (DOMWindowClass self) => Signal self (EventM MouseEvent self ()) -domWindowOnmouseover = (connect "mouseover") - -domWindowOnmouseup :: - (DOMWindowClass self) => Signal self (EventM MouseEvent self ()) -domWindowOnmouseup = (connect "mouseup") - -domWindowOnmousewheel :: - (DOMWindowClass self) => Signal self (EventM MouseEvent self ()) -domWindowOnmousewheel = (connect "mousewheel") - -domWindowOnoffline :: - (DOMWindowClass self) => Signal self (EventM UIEvent self ()) -domWindowOnoffline = (connect "offline") - -domWindowOnonline :: - (DOMWindowClass self) => Signal self (EventM UIEvent self ()) -domWindowOnonline = (connect "online") - -domWindowOnpagehide :: - (DOMWindowClass self) => Signal self (EventM UIEvent self ()) -domWindowOnpagehide = (connect "pagehide") - -domWindowOnpageshow :: - (DOMWindowClass self) => Signal self (EventM UIEvent self ()) -domWindowOnpageshow = (connect "pageshow") - -domWindowOnpause :: - (DOMWindowClass self) => Signal self (EventM UIEvent self ()) -domWindowOnpause = (connect "pause") - -domWindowOnplay :: - (DOMWindowClass self) => Signal self (EventM UIEvent self ()) -domWindowOnplay = (connect "play") - -domWindowOnplaying :: - (DOMWindowClass self) => Signal self (EventM UIEvent self ()) -domWindowOnplaying = (connect "playing") - -domWindowOnpopstate :: - (DOMWindowClass self) => Signal self (EventM UIEvent self ()) -domWindowOnpopstate = (connect "popstate") - -domWindowOnprogress :: - (DOMWindowClass self) => Signal self (EventM UIEvent self ()) -domWindowOnprogress = (connect "progress") - -domWindowOnratechange :: - (DOMWindowClass self) => Signal self (EventM UIEvent self ()) -domWindowOnratechange = (connect "ratechange") - -domWindowOnresize :: - (DOMWindowClass self) => Signal self (EventM UIEvent self ()) -domWindowOnresize = (connect "resize") - -domWindowOnscroll :: - (DOMWindowClass self) => Signal self (EventM UIEvent self ()) -domWindowOnscroll = (connect "scroll") - -domWindowOnseeked :: - (DOMWindowClass self) => Signal self (EventM UIEvent self ()) -domWindowOnseeked = (connect "seeked") - -domWindowOnseeking :: - (DOMWindowClass self) => Signal self (EventM UIEvent self ()) -domWindowOnseeking = (connect "seeking") - -domWindowOnselect :: - (DOMWindowClass self) => Signal self (EventM UIEvent self ()) -domWindowOnselect = (connect "select") - -domWindowOnstalled :: - (DOMWindowClass self) => Signal self (EventM UIEvent self ()) -domWindowOnstalled = (connect "stalled") - -domWindowOnstorage :: - (DOMWindowClass self) => Signal self (EventM UIEvent self ()) -domWindowOnstorage = (connect "storage") - -domWindowOnsubmit :: - (DOMWindowClass self) => Signal self (EventM UIEvent self ()) -domWindowOnsubmit = (connect "submit") - -domWindowOnsuspend :: - (DOMWindowClass self) => Signal self (EventM UIEvent self ()) -domWindowOnsuspend = (connect "suspend") - -domWindowOntimeupdate :: - (DOMWindowClass self) => Signal self (EventM UIEvent self ()) -domWindowOntimeupdate = (connect "timeupdate") - -domWindowOnunload :: - (DOMWindowClass self) => Signal self (EventM UIEvent self ()) -domWindowOnunload = (connect "unload") - -domWindowOnvolumechange :: - (DOMWindowClass self) => Signal self (EventM UIEvent self ()) -domWindowOnvolumechange = (connect "volumechange") - -domWindowOnwaiting :: - (DOMWindowClass self) => Signal self (EventM UIEvent self ()) -domWindowOnwaiting = (connect "waiting") - -domWindowOnreset :: - (DOMWindowClass self) => Signal self (EventM UIEvent self ()) -domWindowOnreset = (connect "reset") - -domWindowOnsearch :: - (DOMWindowClass self) => Signal self (EventM UIEvent self ()) -domWindowOnsearch = (connect "search") - -domWindowOnwebkitanimationend :: - (DOMWindowClass self) => Signal self (EventM UIEvent self ()) -domWindowOnwebkitanimationend = (connect "webkitanimationend") - -domWindowOnwebkitanimationiteration :: - (DOMWindowClass self) => Signal self (EventM UIEvent self ()) -domWindowOnwebkitanimationiteration - = (connect "webkitanimationiteration") - -domWindowOnwebkitanimationstart :: - (DOMWindowClass self) => Signal self (EventM UIEvent self ()) -domWindowOnwebkitanimationstart = (connect "webkitanimationstart") - -domWindowOnwebkittransitionend :: - (DOMWindowClass self) => Signal self (EventM UIEvent self ()) -domWindowOnwebkittransitionend = (connect "webkittransitionend") - -#if WEBKIT_CHECK_VERSION(2,2,2) -domWindowOntransitionend :: - (DOMWindowClass self) => Signal self (EventM UIEvent self ()) -domWindowOntransitionend = (connect "transitionend") -#endif - -domWindowOntouchstart :: - (DOMWindowClass self) => Signal self (EventM UIEvent self ()) -domWindowOntouchstart = (connect "touchstart") - -domWindowOntouchmove :: - (DOMWindowClass self) => Signal self (EventM UIEvent self ()) -domWindowOntouchmove = (connect "touchmove") - -domWindowOntouchend :: - (DOMWindowClass self) => Signal self (EventM UIEvent self ()) -domWindowOntouchend = (connect "touchend") - -domWindowOntouchcancel :: - (DOMWindowClass self) => Signal self (EventM UIEvent self ()) -domWindowOntouchcancel = (connect "touchcancel") - -domWindowOndevicemotion :: - (DOMWindowClass self) => Signal self (EventM UIEvent self ()) -domWindowOndevicemotion = (connect "devicemotion") - -domWindowOndeviceorientation :: - (DOMWindowClass self) => Signal self (EventM UIEvent self ()) -domWindowOndeviceorientation = (connect "deviceorientation") - -#if WEBKIT_CHECK_VERSION(1,10,0) -domWindowOnwebkitdeviceproximity :: - (DOMWindowClass self) => Signal self (EventM UIEvent self ()) -domWindowOnwebkitdeviceproximity - = (connect "webkitdeviceproximity") -#endif diff --git a/Graphics/UI/Gtk/WebKit/DOM/DOMWindowCSS.chs b/Graphics/UI/Gtk/WebKit/DOM/DOMWindowCSS.chs deleted file mode 100644 --- a/Graphics/UI/Gtk/WebKit/DOM/DOMWindowCSS.chs +++ /dev/null @@ -1,27 +0,0 @@ -module Graphics.UI.Gtk.WebKit.DOM.DOMWindowCSS - ( -#if WEBKIT_CHECK_VERSION(2,2,2) - domWindowCSSSupports, DOMWindowCSS, DOMWindowCSSClass, - castToDOMWindowCSS, gTypeDOMWindowCSS, toDOMWindowCSS -#endif - ) where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} -import System.Glib.GError -import Graphics.UI.Gtk.WebKit.DOM.EventM - -#if WEBKIT_CHECK_VERSION(2,2,2) -domWindowCSSSupports :: - (DOMWindowCSSClass self) => self -> String -> String -> IO Bool -domWindowCSSSupports self property value - = toBool <$> - (withUTFString value $ - \ valuePtr -> - withUTFString property $ - \ propertyPtr -> - {# call webkit_dom_dom_window_css_supports #} (toDOMWindowCSS self) - propertyPtr - valuePtr) -#endif diff --git a/Graphics/UI/Gtk/WebKit/DOM/Document.chs b/Graphics/UI/Gtk/WebKit/DOM/Document.chs --- a/Graphics/UI/Gtk/WebKit/DOM/Document.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/Document.chs @@ -1,1050 +1,1326 @@ -module Graphics.UI.Gtk.WebKit.DOM.Document - (documentCreateElement, documentCreateDocumentFragment, - documentCreateTextNode, documentCreateComment, - documentCreateCDATASection, documentCreateProcessingInstruction, - documentCreateAttribute, documentCreateEntityReference, - documentGetElementsByTagName, documentImportNode, - documentCreateElementNS, documentCreateAttributeNS, - documentGetElementsByTagNameNS, documentGetElementById, - documentAdoptNode, documentCreateEvent, documentCreateRange, - documentCreateNodeIterator, documentCreateTreeWalker, - documentGetOverrideStyle, documentCreateExpression, - documentCreateNSResolver, documentEvaluate, documentExecCommand, - documentQueryCommandEnabled, documentQueryCommandIndeterm, - documentQueryCommandState, documentQueryCommandSupported, - documentQueryCommandValue, documentGetElementsByName, - documentElementFromPoint, documentCaretRangeFromPoint, - documentCreateCSSStyleDeclaration, documentGetElementsByClassName, - documentQuerySelector, documentQuerySelectorAll, -#if WEBKIT_CHECK_VERSION(2,2,2) - documentWebkitExitPointerLock, documentWebkitGetNamedFlows, -#endif - documentGetDoctype, documentGetImplementation, - documentGetDocumentElement, documentGetInputEncoding, - documentGetXmlEncoding, documentSetXmlVersion, - documentGetXmlVersion, documentSetXmlStandalone, - documentGetXmlStandalone, documentSetDocumentURI, - documentGetDocumentURI, documentGetDefaultView, - documentGetStyleSheets, documentSetTitle, documentGetTitle, - documentGetReferrer, documentGetDomain, documentSetCookie, - documentGetCookie, documentSetBody, documentGetBody, - documentGetHead, documentGetImages, documentGetApplets, - documentGetLinks, documentGetForms, documentGetAnchors, - documentGetLastModified, documentSetCharset, documentGetCharset, - documentGetDefaultCharset, documentGetReadyState, - documentGetCharacterSet, documentGetPreferredStylesheetSet, - documentSetSelectedStylesheetSet, documentGetSelectedStylesheetSet, - documentGetCompatMode, -#if WEBKIT_CHECK_VERSION(1,10,0) - documentGetWebkitPointerLockElement, -#endif - documentOnabort, documentOnblur, documentOnchange, documentOnclick, - documentOncontextmenu, documentOndblclick, documentOndrag, - documentOndragend, documentOndragenter, documentOndragleave, - documentOndragover, documentOndragstart, documentOndrop, - documentOnerror, documentOnfocus, documentOninput, - documentOninvalid, documentOnkeydown, documentOnkeypress, - documentOnkeyup, documentOnload, documentOnmousedown, -#if WEBKIT_CHECK_VERSION(2,2,2) - documentOnmouseenter, documentOnmouseleave, -#endif - documentOnmousemove, documentOnmouseout, documentOnmouseover, - documentOnmouseup, documentOnmousewheel, - documentOnreadystatechange, documentOnscroll, documentOnselect, - documentOnsubmit, documentOnbeforecut, documentOncut, - documentOnbeforecopy, documentOncopy, documentOnbeforepaste, - documentOnpaste, documentOnreset, documentOnsearch, - documentOnselectstart, documentOnselectionchange, - documentOntouchstart, documentOntouchmove, documentOntouchend, - documentOntouchcancel, documentOnwebkitfullscreenchange, - documentOnwebkitfullscreenerror, -#if WEBKIT_CHECK_VERSION(1,10,0) - documentOnwebkitpointerlockchange, documentOnwebkitpointerlockerror, -#endif -#if WEBKIT_CHECK_VERSION(2,2,2) - documentOnsecuritypolicyviolation, -#endif - documentGetVisibilityState, - documentGetHidden, -#if WEBKIT_CHECK_VERSION(1,10,0) - documentGetSecurityPolicy, -#endif -#if WEBKIT_CHECK_VERSION(2,2,2) - documentGetCurrentScript, -#endif - Document, DocumentClass, castToDocument, gTypeDocument, toDocument) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} -import System.Glib.GError -import Graphics.UI.Gtk.WebKit.DOM.EventM - -documentCreateElement :: - (DocumentClass self) => self -> String -> IO (Maybe Element) -documentCreateElement self tagName - = maybeNull (makeNewGObject mkElement) - (propagateGError $ - \ errorPtr_ -> - withUTFString tagName $ - \ tagNamePtr -> - {# call webkit_dom_document_create_element #} (toDocument self) - tagNamePtr - errorPtr_) - -documentCreateDocumentFragment :: - (DocumentClass self) => self -> IO (Maybe DocumentFragment) -documentCreateDocumentFragment self - = maybeNull (makeNewGObject mkDocumentFragment) - ({# call webkit_dom_document_create_document_fragment #} - (toDocument self)) - -documentCreateTextNode :: - (DocumentClass self) => self -> String -> IO (Maybe Text) -documentCreateTextNode self data' - = maybeNull (makeNewGObject mkText) - (withUTFString data' $ - \ dataPtr -> - {# call webkit_dom_document_create_text_node #} (toDocument self) - dataPtr) - -documentCreateComment :: - (DocumentClass self) => self -> String -> IO (Maybe Comment) -documentCreateComment self data' - = maybeNull (makeNewGObject mkComment) - (withUTFString data' $ - \ dataPtr -> - {# call webkit_dom_document_create_comment #} (toDocument self) - dataPtr) - -documentCreateCDATASection :: - (DocumentClass self) => self -> String -> IO (Maybe CDATASection) -documentCreateCDATASection self data' - = maybeNull (makeNewGObject mkCDATASection) - (propagateGError $ - \ errorPtr_ -> - withUTFString data' $ - \ dataPtr -> - {# call webkit_dom_document_create_cdata_section #} - (toDocument self) - dataPtr - errorPtr_) - -documentCreateProcessingInstruction :: - (DocumentClass self) => - self -> String -> String -> IO (Maybe ProcessingInstruction) -documentCreateProcessingInstruction self target data' - = maybeNull (makeNewGObject mkProcessingInstruction) - (propagateGError $ - \ errorPtr_ -> - withUTFString data' $ - \ dataPtr -> - withUTFString target $ - \ targetPtr -> - {# call webkit_dom_document_create_processing_instruction #} - (toDocument self) - targetPtr - dataPtr - errorPtr_) - -documentCreateAttribute :: - (DocumentClass self) => self -> String -> IO (Maybe DOMAttr) -documentCreateAttribute self name - = maybeNull (makeNewGObject mkDOMAttr) - (propagateGError $ - \ errorPtr_ -> - withUTFString name $ - \ namePtr -> - {# call webkit_dom_document_create_attribute #} (toDocument self) - namePtr - errorPtr_) - -documentCreateEntityReference :: - (DocumentClass self) => - self -> String -> IO (Maybe EntityReference) -documentCreateEntityReference self name - = maybeNull (makeNewGObject mkEntityReference) - (propagateGError $ - \ errorPtr_ -> - withUTFString name $ - \ namePtr -> - {# call webkit_dom_document_create_entity_reference #} - (toDocument self) - namePtr - errorPtr_) - -documentGetElementsByTagName :: - (DocumentClass self) => self -> String -> IO (Maybe NodeList) -documentGetElementsByTagName self tagname - = maybeNull (makeNewGObject mkNodeList) - (withUTFString tagname $ - \ tagnamePtr -> - {# call webkit_dom_document_get_elements_by_tag_name #} - (toDocument self) - tagnamePtr) - -documentImportNode :: - (DocumentClass self, NodeClass importedNode) => - self -> Maybe importedNode -> Bool -> IO (Maybe Node) -documentImportNode self importedNode deep - = maybeNull (makeNewGObject mkNode) - (propagateGError $ - \ errorPtr_ -> - {# call webkit_dom_document_import_node #} (toDocument self) - (maybe (Node nullForeignPtr) toNode importedNode) - (fromBool deep) - errorPtr_) - -documentCreateElementNS :: - (DocumentClass self) => - self -> String -> String -> IO (Maybe Element) -documentCreateElementNS self namespaceURI qualifiedName - = maybeNull (makeNewGObject mkElement) - (propagateGError $ - \ errorPtr_ -> - withUTFString qualifiedName $ - \ qualifiedNamePtr -> - withUTFString namespaceURI $ - \ namespaceURIPtr -> - {# call webkit_dom_document_create_element_ns #} (toDocument self) - namespaceURIPtr - qualifiedNamePtr - errorPtr_) - -documentCreateAttributeNS :: - (DocumentClass self) => - self -> String -> String -> IO (Maybe DOMAttr) -documentCreateAttributeNS self namespaceURI qualifiedName - = maybeNull (makeNewGObject mkDOMAttr) - (propagateGError $ - \ errorPtr_ -> - withUTFString qualifiedName $ - \ qualifiedNamePtr -> - withUTFString namespaceURI $ - \ namespaceURIPtr -> - {# call webkit_dom_document_create_attribute_ns #} - (toDocument self) - namespaceURIPtr - qualifiedNamePtr - errorPtr_) - -documentGetElementsByTagNameNS :: - (DocumentClass self) => - self -> String -> String -> IO (Maybe NodeList) -documentGetElementsByTagNameNS self namespaceURI localName - = maybeNull (makeNewGObject mkNodeList) - (withUTFString localName $ - \ localNamePtr -> - withUTFString namespaceURI $ - \ namespaceURIPtr -> - {# call webkit_dom_document_get_elements_by_tag_name_ns #} - (toDocument self) - namespaceURIPtr - localNamePtr) - -documentGetElementById :: - (DocumentClass self) => self -> String -> IO (Maybe Element) -documentGetElementById self elementId - = maybeNull (makeNewGObject mkElement) - (withUTFString elementId $ - \ elementIdPtr -> - {# call webkit_dom_document_get_element_by_id #} (toDocument self) - elementIdPtr) - -documentAdoptNode :: - (DocumentClass self, NodeClass source) => - self -> Maybe source -> IO (Maybe Node) -documentAdoptNode self source - = maybeNull (makeNewGObject mkNode) - (propagateGError $ - \ errorPtr_ -> - {# call webkit_dom_document_adopt_node #} (toDocument self) - (maybe (Node nullForeignPtr) toNode source) - errorPtr_) - -documentCreateEvent :: - (DocumentClass self) => self -> String -> IO (Maybe Event) -documentCreateEvent self eventType - = maybeNull (makeNewGObject mkEvent) - (propagateGError $ - \ errorPtr_ -> - withUTFString eventType $ - \ eventTypePtr -> - {# call webkit_dom_document_create_event #} (toDocument self) - eventTypePtr - errorPtr_) - -documentCreateRange :: - (DocumentClass self) => self -> IO (Maybe DOMRange) -documentCreateRange self - = maybeNull (makeNewGObject mkDOMRange) - ({# call webkit_dom_document_create_range #} (toDocument self)) - -documentCreateNodeIterator :: - (DocumentClass self, NodeClass root, NodeFilterClass filter) => - self -> - Maybe root -> - Word -> Maybe filter -> Bool -> IO (Maybe NodeIterator) -documentCreateNodeIterator self root whatToShow filter - expandEntityReferences - = maybeNull (makeNewGObject mkNodeIterator) - (propagateGError $ - \ errorPtr_ -> - {# call webkit_dom_document_create_node_iterator #} - (toDocument self) - (maybe (Node nullForeignPtr) toNode root) - (fromIntegral whatToShow) - (maybe (NodeFilter nullForeignPtr) toNodeFilter filter) - (fromBool expandEntityReferences) - errorPtr_) - -documentCreateTreeWalker :: - (DocumentClass self, NodeClass root, NodeFilterClass filter) => - self -> - Maybe root -> Word -> Maybe filter -> Bool -> IO (Maybe TreeWalker) -documentCreateTreeWalker self root whatToShow filter - expandEntityReferences - = maybeNull (makeNewGObject mkTreeWalker) - (propagateGError $ - \ errorPtr_ -> - {# call webkit_dom_document_create_tree_walker #} (toDocument self) - (maybe (Node nullForeignPtr) toNode root) - (fromIntegral whatToShow) - (maybe (NodeFilter nullForeignPtr) toNodeFilter filter) - (fromBool expandEntityReferences) - errorPtr_) - -documentGetOverrideStyle :: - (DocumentClass self, ElementClass element) => - self -> Maybe element -> String -> IO (Maybe CSSStyleDeclaration) -documentGetOverrideStyle self element pseudoElement - = maybeNull (makeNewGObject mkCSSStyleDeclaration) - (withUTFString pseudoElement $ - \ pseudoElementPtr -> - {# call webkit_dom_document_get_override_style #} (toDocument self) - (maybe (Element nullForeignPtr) toElement element) - pseudoElementPtr) - -documentCreateExpression :: - (DocumentClass self, XPathNSResolverClass resolver) => - self -> String -> Maybe resolver -> IO (Maybe XPathExpression) -documentCreateExpression self expression resolver - = maybeNull (makeNewGObject mkXPathExpression) - (propagateGError $ - \ errorPtr_ -> - withUTFString expression $ - \ expressionPtr -> - {# call webkit_dom_document_create_expression #} (toDocument self) - expressionPtr - (maybe (XPathNSResolver nullForeignPtr) toXPathNSResolver resolver) - errorPtr_) - -documentCreateNSResolver :: - (DocumentClass self, NodeClass nodeResolver) => - self -> Maybe nodeResolver -> IO (Maybe XPathNSResolver) -documentCreateNSResolver self nodeResolver - = maybeNull (makeNewGObject mkXPathNSResolver) - ({# call webkit_dom_document_create_ns_resolver #} - (toDocument self) - (maybe (Node nullForeignPtr) toNode nodeResolver)) - -documentEvaluate :: - (DocumentClass self, NodeClass contextNode, - XPathNSResolverClass resolver, XPathResultClass inResult) => - self -> - String -> - Maybe contextNode -> - Maybe resolver -> Word -> Maybe inResult -> IO (Maybe XPathResult) -documentEvaluate self expression contextNode resolver type' - inResult - = maybeNull (makeNewGObject mkXPathResult) - (propagateGError $ - \ errorPtr_ -> - withUTFString expression $ - \ expressionPtr -> - {# call webkit_dom_document_evaluate #} (toDocument self) - expressionPtr - (maybe (Node nullForeignPtr) toNode contextNode) - (maybe (XPathNSResolver nullForeignPtr) toXPathNSResolver resolver) - (fromIntegral type') - (maybe (XPathResult nullForeignPtr) toXPathResult inResult) - errorPtr_) - -documentExecCommand :: - (DocumentClass self) => self -> String -> Bool -> String -> IO Bool -documentExecCommand self command userInterface value - = toBool <$> - (withUTFString value $ - \ valuePtr -> - withUTFString command $ - \ commandPtr -> - {# call webkit_dom_document_exec_command #} (toDocument self) - commandPtr - (fromBool userInterface) - valuePtr) - -documentQueryCommandEnabled :: - (DocumentClass self) => self -> String -> IO Bool -documentQueryCommandEnabled self command - = toBool <$> - (withUTFString command $ - \ commandPtr -> - {# call webkit_dom_document_query_command_enabled #} - (toDocument self) - commandPtr) - -documentQueryCommandIndeterm :: - (DocumentClass self) => self -> String -> IO Bool -documentQueryCommandIndeterm self command - = toBool <$> - (withUTFString command $ - \ commandPtr -> - {# call webkit_dom_document_query_command_indeterm #} - (toDocument self) - commandPtr) - -documentQueryCommandState :: - (DocumentClass self) => self -> String -> IO Bool -documentQueryCommandState self command - = toBool <$> - (withUTFString command $ - \ commandPtr -> - {# call webkit_dom_document_query_command_state #} - (toDocument self) - commandPtr) - -documentQueryCommandSupported :: - (DocumentClass self) => self -> String -> IO Bool -documentQueryCommandSupported self command - = toBool <$> - (withUTFString command $ - \ commandPtr -> - {# call webkit_dom_document_query_command_supported #} - (toDocument self) - commandPtr) - -documentQueryCommandValue :: - (DocumentClass self) => self -> String -> IO String -documentQueryCommandValue self command - = (withUTFString command $ - \ commandPtr -> - {# call webkit_dom_document_query_command_value #} - (toDocument self) - commandPtr) - >>= - readUTFString - -documentGetElementsByName :: - (DocumentClass self) => self -> String -> IO (Maybe NodeList) -documentGetElementsByName self elementName - = maybeNull (makeNewGObject mkNodeList) - (withUTFString elementName $ - \ elementNamePtr -> - {# call webkit_dom_document_get_elements_by_name #} - (toDocument self) - elementNamePtr) - -documentElementFromPoint :: - (DocumentClass self) => self -> Int -> Int -> IO (Maybe Element) -documentElementFromPoint self x y - = maybeNull (makeNewGObject mkElement) - ({# call webkit_dom_document_element_from_point #} - (toDocument self) - (fromIntegral x) - (fromIntegral y)) - -documentCaretRangeFromPoint :: - (DocumentClass self) => self -> Int -> Int -> IO (Maybe DOMRange) -documentCaretRangeFromPoint self x y - = maybeNull (makeNewGObject mkDOMRange) - ({# call webkit_dom_document_caret_range_from_point #} - (toDocument self) - (fromIntegral x) - (fromIntegral y)) - -documentCreateCSSStyleDeclaration :: - (DocumentClass self) => self -> IO (Maybe CSSStyleDeclaration) -documentCreateCSSStyleDeclaration self - = maybeNull (makeNewGObject mkCSSStyleDeclaration) - ({# call webkit_dom_document_create_css_style_declaration #} - (toDocument self)) - -documentGetElementsByClassName :: - (DocumentClass self) => self -> String -> IO (Maybe NodeList) -documentGetElementsByClassName self tagname - = maybeNull (makeNewGObject mkNodeList) - (withUTFString tagname $ - \ tagnamePtr -> - {# call webkit_dom_document_get_elements_by_class_name #} - (toDocument self) - tagnamePtr) - -documentQuerySelector :: - (DocumentClass self) => self -> String -> IO (Maybe Element) -documentQuerySelector self selectors - = maybeNull (makeNewGObject mkElement) - (propagateGError $ - \ errorPtr_ -> - withUTFString selectors $ - \ selectorsPtr -> - {# call webkit_dom_document_query_selector #} (toDocument self) - selectorsPtr - errorPtr_) - -documentQuerySelectorAll :: - (DocumentClass self) => self -> String -> IO (Maybe NodeList) -documentQuerySelectorAll self selectors - = maybeNull (makeNewGObject mkNodeList) - (propagateGError $ - \ errorPtr_ -> - withUTFString selectors $ - \ selectorsPtr -> - {# call webkit_dom_document_query_selector_all #} (toDocument self) - selectorsPtr - errorPtr_) - -#if WEBKIT_CHECK_VERSION(2,2,2) -documentWebkitExitPointerLock :: - (DocumentClass self) => self -> IO () -documentWebkitExitPointerLock self - = {# call webkit_dom_document_webkit_exit_pointer_lock #} - (toDocument self) - -documentWebkitGetNamedFlows :: - (DocumentClass self) => self -> IO (Maybe DOMNamedFlowCollection) -documentWebkitGetNamedFlows self - = maybeNull (makeNewGObject mkDOMNamedFlowCollection) - ({# call webkit_dom_document_webkit_get_named_flows #} - (toDocument self)) -#endif - -documentGetDoctype :: - (DocumentClass self) => self -> IO (Maybe DocumentType) -documentGetDoctype self - = maybeNull (makeNewGObject mkDocumentType) - ({# call webkit_dom_document_get_doctype #} (toDocument self)) - -documentGetImplementation :: - (DocumentClass self) => self -> IO (Maybe DOMImplementation) -documentGetImplementation self - = maybeNull (makeNewGObject mkDOMImplementation) - ({# call webkit_dom_document_get_implementation #} - (toDocument self)) - -documentGetDocumentElement :: - (DocumentClass self) => self -> IO (Maybe Element) -documentGetDocumentElement self - = maybeNull (makeNewGObject mkElement) - ({# call webkit_dom_document_get_document_element #} - (toDocument self)) - -documentGetInputEncoding :: - (DocumentClass self) => self -> IO String -documentGetInputEncoding self - = ({# call webkit_dom_document_get_input_encoding #} - (toDocument self)) - >>= - readUTFString - -documentGetXmlEncoding :: (DocumentClass self) => self -> IO String -documentGetXmlEncoding self - = ({# call webkit_dom_document_get_xml_encoding #} - (toDocument self)) - >>= - readUTFString - -documentSetXmlVersion :: - (DocumentClass self) => self -> String -> IO () -documentSetXmlVersion self val - = propagateGError $ - \ errorPtr_ -> - withUTFString val $ - \ valPtr -> - {# call webkit_dom_document_set_xml_version #} (toDocument self) - valPtr - errorPtr_ - -documentGetXmlVersion :: (DocumentClass self) => self -> IO String -documentGetXmlVersion self - = ({# call webkit_dom_document_get_xml_version #} - (toDocument self)) - >>= - readUTFString - -documentSetXmlStandalone :: - (DocumentClass self) => self -> Bool -> IO () -documentSetXmlStandalone self val - = propagateGError $ - \ errorPtr_ -> - {# call webkit_dom_document_set_xml_standalone #} (toDocument self) - (fromBool val) - errorPtr_ - -documentGetXmlStandalone :: (DocumentClass self) => self -> IO Bool -documentGetXmlStandalone self - = toBool <$> - ({# call webkit_dom_document_get_xml_standalone #} - (toDocument self)) - -documentSetDocumentURI :: - (DocumentClass self) => self -> String -> IO () -documentSetDocumentURI self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_document_set_document_uri #} (toDocument self) - valPtr - -documentGetDocumentURI :: (DocumentClass self) => self -> IO String -documentGetDocumentURI self - = ({# call webkit_dom_document_get_document_uri #} - (toDocument self)) - >>= - readUTFString - -documentGetDefaultView :: - (DocumentClass self) => self -> IO (Maybe DOMWindow) -documentGetDefaultView self - = maybeNull (makeNewGObject mkDOMWindow) - ({# call webkit_dom_document_get_default_view #} (toDocument self)) - -documentGetStyleSheets :: - (DocumentClass self) => self -> IO (Maybe StyleSheetList) -documentGetStyleSheets self - = maybeNull (makeNewGObject mkStyleSheetList) - ({# call webkit_dom_document_get_style_sheets #} (toDocument self)) - -documentSetTitle :: (DocumentClass self) => self -> String -> IO () -documentSetTitle self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_document_set_title #} (toDocument self) valPtr - -documentGetTitle :: (DocumentClass self) => self -> IO String -documentGetTitle self - = ({# call webkit_dom_document_get_title #} (toDocument self)) >>= - readUTFString - -documentGetReferrer :: (DocumentClass self) => self -> IO String -documentGetReferrer self - = ({# call webkit_dom_document_get_referrer #} (toDocument self)) - >>= - readUTFString - -documentGetDomain :: (DocumentClass self) => self -> IO String -documentGetDomain self - = ({# call webkit_dom_document_get_domain #} (toDocument self)) >>= - readUTFString - -documentSetCookie :: - (DocumentClass self) => self -> String -> IO () -documentSetCookie self val - = propagateGError $ - \ errorPtr_ -> - withUTFString val $ - \ valPtr -> - {# call webkit_dom_document_set_cookie #} (toDocument self) valPtr - errorPtr_ - -documentGetCookie :: (DocumentClass self) => self -> IO String -documentGetCookie self - = (propagateGError $ - \ errorPtr_ -> - {# call webkit_dom_document_get_cookie #} (toDocument self) - errorPtr_) - >>= - readUTFString - -documentSetBody :: - (HTMLElementClass val, DocumentClass self) => - self -> Maybe val -> IO () -documentSetBody self val - = propagateGError $ - \ errorPtr_ -> - {# call webkit_dom_document_set_body #} (toDocument self) - (maybe (HTMLElement nullForeignPtr) toHTMLElement val) - errorPtr_ - -documentGetBody :: - (DocumentClass self) => self -> IO (Maybe HTMLElement) -documentGetBody self - = maybeNull (makeNewGObject mkHTMLElement) - ({# call webkit_dom_document_get_body #} (toDocument self)) - -documentGetHead :: - (DocumentClass self) => self -> IO (Maybe HTMLHeadElement) -documentGetHead self - = maybeNull (makeNewGObject mkHTMLHeadElement) - ({# call webkit_dom_document_get_head #} (toDocument self)) - -documentGetImages :: - (DocumentClass self) => self -> IO (Maybe HTMLCollection) -documentGetImages self - = maybeNull (makeNewGObject mkHTMLCollection) - ({# call webkit_dom_document_get_images #} (toDocument self)) - -documentGetApplets :: - (DocumentClass self) => self -> IO (Maybe HTMLCollection) -documentGetApplets self - = maybeNull (makeNewGObject mkHTMLCollection) - ({# call webkit_dom_document_get_applets #} (toDocument self)) - -documentGetLinks :: - (DocumentClass self) => self -> IO (Maybe HTMLCollection) -documentGetLinks self - = maybeNull (makeNewGObject mkHTMLCollection) - ({# call webkit_dom_document_get_links #} (toDocument self)) - -documentGetForms :: - (DocumentClass self) => self -> IO (Maybe HTMLCollection) -documentGetForms self - = maybeNull (makeNewGObject mkHTMLCollection) - ({# call webkit_dom_document_get_forms #} (toDocument self)) - -documentGetAnchors :: - (DocumentClass self) => self -> IO (Maybe HTMLCollection) -documentGetAnchors self - = maybeNull (makeNewGObject mkHTMLCollection) - ({# call webkit_dom_document_get_anchors #} (toDocument self)) - -documentGetLastModified :: - (DocumentClass self) => self -> IO String -documentGetLastModified self - = ({# call webkit_dom_document_get_last_modified #} - (toDocument self)) - >>= - readUTFString - -documentSetCharset :: - (DocumentClass self) => self -> String -> IO () -documentSetCharset self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_document_set_charset #} (toDocument self) valPtr - -documentGetCharset :: (DocumentClass self) => self -> IO String -documentGetCharset self - = ({# call webkit_dom_document_get_charset #} (toDocument self)) - >>= - readUTFString - -documentGetDefaultCharset :: - (DocumentClass self) => self -> IO String -documentGetDefaultCharset self - = ({# call webkit_dom_document_get_default_charset #} - (toDocument self)) - >>= - readUTFString - -documentGetReadyState :: (DocumentClass self) => self -> IO String -documentGetReadyState self - = ({# call webkit_dom_document_get_ready_state #} - (toDocument self)) - >>= - readUTFString - -documentGetCharacterSet :: - (DocumentClass self) => self -> IO String -documentGetCharacterSet self - = ({# call webkit_dom_document_get_character_set #} - (toDocument self)) - >>= - readUTFString - -documentGetPreferredStylesheetSet :: - (DocumentClass self) => self -> IO String -documentGetPreferredStylesheetSet self - = ({# call webkit_dom_document_get_preferred_stylesheet_set #} - (toDocument self)) - >>= - readUTFString - -documentSetSelectedStylesheetSet :: - (DocumentClass self) => self -> String -> IO () -documentSetSelectedStylesheetSet self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_document_set_selected_stylesheet_set #} - (toDocument self) - valPtr - -documentGetSelectedStylesheetSet :: - (DocumentClass self) => self -> IO String -documentGetSelectedStylesheetSet self - = ({# call webkit_dom_document_get_selected_stylesheet_set #} - (toDocument self)) - >>= - readUTFString - -documentGetCompatMode :: (DocumentClass self) => self -> IO String -documentGetCompatMode self - = ({# call webkit_dom_document_get_compat_mode #} - (toDocument self)) - >>= - readUTFString - -#if WEBKIT_CHECK_VERSION(1,10,0) -documentGetWebkitPointerLockElement :: - (DocumentClass self) => self -> IO (Maybe Element) -documentGetWebkitPointerLockElement self - = maybeNull (makeNewGObject mkElement) - ({# call webkit_dom_document_get_webkit_pointer_lock_element #} - (toDocument self)) -#endif - -documentOnabort :: - (DocumentClass self) => Signal self (EventM UIEvent self ()) -documentOnabort = (connect "abort") - -documentOnblur :: - (DocumentClass self) => Signal self (EventM UIEvent self ()) -documentOnblur = (connect "blur") - -documentOnchange :: - (DocumentClass self) => Signal self (EventM UIEvent self ()) -documentOnchange = (connect "change") - -documentOnclick :: - (DocumentClass self) => Signal self (EventM MouseEvent self ()) -documentOnclick = (connect "click") - -documentOncontextmenu :: - (DocumentClass self) => Signal self (EventM MouseEvent self ()) -documentOncontextmenu = (connect "contextmenu") - -documentOndblclick :: - (DocumentClass self) => Signal self (EventM MouseEvent self ()) -documentOndblclick = (connect "dblclick") - -documentOndrag :: - (DocumentClass self) => Signal self (EventM MouseEvent self ()) -documentOndrag = (connect "drag") - -documentOndragend :: - (DocumentClass self) => Signal self (EventM MouseEvent self ()) -documentOndragend = (connect "dragend") - -documentOndragenter :: - (DocumentClass self) => Signal self (EventM MouseEvent self ()) -documentOndragenter = (connect "dragenter") - -documentOndragleave :: - (DocumentClass self) => Signal self (EventM MouseEvent self ()) -documentOndragleave = (connect "dragleave") - -documentOndragover :: - (DocumentClass self) => Signal self (EventM MouseEvent self ()) -documentOndragover = (connect "dragover") - -documentOndragstart :: - (DocumentClass self) => Signal self (EventM MouseEvent self ()) -documentOndragstart = (connect "dragstart") - -documentOndrop :: - (DocumentClass self) => Signal self (EventM MouseEvent self ()) -documentOndrop = (connect "drop") - -documentOnerror :: - (DocumentClass self) => Signal self (EventM UIEvent self ()) -documentOnerror = (connect "error") - -documentOnfocus :: - (DocumentClass self) => Signal self (EventM UIEvent self ()) -documentOnfocus = (connect "focus") - -documentOninput :: - (DocumentClass self) => Signal self (EventM UIEvent self ()) -documentOninput = (connect "input") - -documentOninvalid :: - (DocumentClass self) => Signal self (EventM UIEvent self ()) -documentOninvalid = (connect "invalid") - -documentOnkeydown :: - (DocumentClass self) => Signal self (EventM UIEvent self ()) -documentOnkeydown = (connect "keydown") - -documentOnkeypress :: - (DocumentClass self) => Signal self (EventM UIEvent self ()) -documentOnkeypress = (connect "keypress") - -documentOnkeyup :: - (DocumentClass self) => Signal self (EventM UIEvent self ()) -documentOnkeyup = (connect "keyup") - -documentOnload :: - (DocumentClass self) => Signal self (EventM UIEvent self ()) -documentOnload = (connect "load") - -documentOnmousedown :: - (DocumentClass self) => Signal self (EventM MouseEvent self ()) -documentOnmousedown = (connect "mousedown") - -#if WEBKIT_CHECK_VERSION(2,2,2) -documentOnmouseenter :: - (DocumentClass self) => Signal self (EventM UIEvent self ()) -documentOnmouseenter = (connect "mouseenter") - -documentOnmouseleave :: - (DocumentClass self) => Signal self (EventM UIEvent self ()) -documentOnmouseleave = (connect "mouseleave") -#endif - -documentOnmousemove :: - (DocumentClass self) => Signal self (EventM MouseEvent self ()) -documentOnmousemove = (connect "mousemove") - -documentOnmouseout :: - (DocumentClass self) => Signal self (EventM MouseEvent self ()) -documentOnmouseout = (connect "mouseout") - -documentOnmouseover :: - (DocumentClass self) => Signal self (EventM MouseEvent self ()) -documentOnmouseover = (connect "mouseover") - -documentOnmouseup :: - (DocumentClass self) => Signal self (EventM MouseEvent self ()) -documentOnmouseup = (connect "mouseup") - -documentOnmousewheel :: - (DocumentClass self) => Signal self (EventM MouseEvent self ()) -documentOnmousewheel = (connect "mousewheel") - -documentOnreadystatechange :: - (DocumentClass self) => Signal self (EventM UIEvent self ()) -documentOnreadystatechange = (connect "readystatechange") - -documentOnscroll :: - (DocumentClass self) => Signal self (EventM UIEvent self ()) -documentOnscroll = (connect "scroll") - -documentOnselect :: - (DocumentClass self) => Signal self (EventM UIEvent self ()) -documentOnselect = (connect "select") - -documentOnsubmit :: - (DocumentClass self) => Signal self (EventM UIEvent self ()) -documentOnsubmit = (connect "submit") - -documentOnbeforecut :: - (DocumentClass self) => Signal self (EventM UIEvent self ()) -documentOnbeforecut = (connect "beforecut") - -documentOncut :: - (DocumentClass self) => Signal self (EventM UIEvent self ()) -documentOncut = (connect "cut") - -documentOnbeforecopy :: - (DocumentClass self) => Signal self (EventM UIEvent self ()) -documentOnbeforecopy = (connect "beforecopy") - -documentOncopy :: - (DocumentClass self) => Signal self (EventM UIEvent self ()) -documentOncopy = (connect "copy") - -documentOnbeforepaste :: - (DocumentClass self) => Signal self (EventM UIEvent self ()) -documentOnbeforepaste = (connect "beforepaste") - -documentOnpaste :: - (DocumentClass self) => Signal self (EventM UIEvent self ()) -documentOnpaste = (connect "paste") - -documentOnreset :: - (DocumentClass self) => Signal self (EventM UIEvent self ()) -documentOnreset = (connect "reset") - -documentOnsearch :: - (DocumentClass self) => Signal self (EventM UIEvent self ()) -documentOnsearch = (connect "search") - -documentOnselectstart :: - (DocumentClass self) => Signal self (EventM UIEvent self ()) -documentOnselectstart = (connect "selectstart") - -documentOnselectionchange :: - (DocumentClass self) => Signal self (EventM UIEvent self ()) -documentOnselectionchange = (connect "selectionchange") - -documentOntouchstart :: - (DocumentClass self) => Signal self (EventM UIEvent self ()) -documentOntouchstart = (connect "touchstart") - -documentOntouchmove :: - (DocumentClass self) => Signal self (EventM UIEvent self ()) -documentOntouchmove = (connect "touchmove") - -documentOntouchend :: - (DocumentClass self) => Signal self (EventM UIEvent self ()) -documentOntouchend = (connect "touchend") - -documentOntouchcancel :: - (DocumentClass self) => Signal self (EventM UIEvent self ()) -documentOntouchcancel = (connect "touchcancel") - -documentOnwebkitfullscreenchange :: - (DocumentClass self) => Signal self (EventM UIEvent self ()) -documentOnwebkitfullscreenchange - = (connect "webkitfullscreenchange") - -documentOnwebkitfullscreenerror :: - (DocumentClass self) => Signal self (EventM UIEvent self ()) -documentOnwebkitfullscreenerror = (connect "webkitfullscreenerror") - -#if WEBKIT_CHECK_VERSION(1,10,0) -documentOnwebkitpointerlockchange :: - (DocumentClass self) => Signal self (EventM UIEvent self ()) -documentOnwebkitpointerlockchange - = (connect "webkitpointerlockchange") - -documentOnwebkitpointerlockerror :: - (DocumentClass self) => Signal self (EventM UIEvent self ()) -documentOnwebkitpointerlockerror - = (connect "webkitpointerlockerror") -#endif - -#if WEBKIT_CHECK_VERSION(2,2,2) -documentOnsecuritypolicyviolation :: - (DocumentClass self) => Signal self (EventM UIEvent self ()) -documentOnsecuritypolicyviolation - = (connect "securitypolicyviolation") -#endif - -documentGetVisibilityState :: - (DocumentClass self) => self -> IO String -documentGetVisibilityState self -#if WEBKIT_CHECK_VERSION(2,2,2) - = ({# call webkit_dom_document_get_visibility_state #} -#else - = ({# call webkit_dom_document_get_webkit_visibility_state #} -#endif - (toDocument self)) - >>= - readUTFString - -documentGetHidden :: (DocumentClass self) => self -> IO Bool -documentGetHidden self - = toBool <$> -#if WEBKIT_CHECK_VERSION(2,2,2) - ({# call webkit_dom_document_get_hidden #} (toDocument self)) -#else - ({# call webkit_dom_document_get_webkit_hidden #} (toDocument self)) -#endif - -#if WEBKIT_CHECK_VERSION(1,10,0) -documentGetSecurityPolicy :: - (DocumentClass self) => self -> IO (Maybe DOMSecurityPolicy) -documentGetSecurityPolicy self - = maybeNull (makeNewGObject mkDOMSecurityPolicy) - ({# call webkit_dom_document_get_security_policy #} - (toDocument self)) -#endif - -#if WEBKIT_CHECK_VERSION(2,2,2) -documentGetCurrentScript :: - (DocumentClass self) => self -> IO (Maybe HTMLScriptElement) -documentGetCurrentScript self - = maybeNull (makeNewGObject mkHTMLScriptElement) - ({# call webkit_dom_document_get_current_script #} - (toDocument self)) +module Graphics.UI.Gtk.WebKit.DOM.Document( +createElement, +createDocumentFragment, +createTextNode, +createComment, +createCDATASection, +createProcessingInstruction, +createAttribute, +createEntityReference, +getElementsByTagName, +importNode, +createElementNS, +createAttributeNS, +getElementsByTagNameNS, +getElementById, +adoptNode, +createEvent, +createRange, +createNodeIterator, +createTreeWalker, +getOverrideStyle, +createExpression, +createNSResolver, +evaluate, +execCommand, +queryCommandEnabled, +queryCommandIndeterm, +queryCommandState, +queryCommandSupported, +queryCommandValue, +getElementsByName, +elementFromPoint, +caretRangeFromPoint, +createCSSStyleDeclaration, +getElementsByClassName, +#if WEBKIT_CHECK_VERSION(2,5,1) +hasFocus, +#endif +querySelector, +querySelectorAll, +webkitCancelFullScreen, +#if WEBKIT_CHECK_VERSION(2,2,2) +webkitExitFullscreen, +webkitGetNamedFlows, +#endif +#if WEBKIT_CHECK_VERSION(2,4,2) +createTouch, +#endif +getDoctype, +getImplementation, +getDocumentElement, +getInputEncoding, +getXmlEncoding, +setXmlVersion, +getXmlVersion, +setXmlStandalone, +getXmlStandalone, +getDocumentURI, +getDefaultView, +getStyleSheets, +setTitle, +getTitle, +getReferrer, +getDomain, +setCookie, +getCookie, +setBody, +getBody, +getHead, +getImages, +getApplets, +getLinks, +getForms, +getAnchors, +getLastModified, +setCharset, +getCharset, +getDefaultCharset, +getReadyState, +getCharacterSet, +getPreferredStylesheetSet, +setSelectedStylesheetSet, +getSelectedStylesheetSet, +getCompatMode, +getWebkitIsFullScreen, +getWebkitFullScreenKeyboardInputAllowed, +getWebkitCurrentFullScreenElement, +#if WEBKIT_CHECK_VERSION(2,2,2) +getWebkitFullscreenEnabled, +getWebkitFullscreenElement, +#endif +abort, +blur, +change, +click, +contextMenu, +dblClick, +drag, +dragEnd, +dragEnter, +dragLeave, +dragOver, +dragStart, +drop, +error, +focus, +input, +invalid, +#if WEBKIT_CHECK_VERSION(2,2,2) +keyDown, +keyPress, +keyUp, +#endif +load, +mouseDown, +mouseEnter, +mouseLeave, +mouseMove, +mouseOut, +mouseOver, +mouseUp, +mouseWheel, +readyStateChange, +scroll, +select, +submit, +#if WEBKIT_CHECK_VERSION(2,4,0) +wheel, +#endif +beforeCut, +cut, +beforeCopy, +copy, +beforePaste, +paste, +reset, +search, +selectStart, +selectionchange, +touchStart, +touchMove, +touchEnd, +touchCancel, +webKitFullscreenChange, +webKitFullscreenError, +pointerlockchange, +pointerlockerror, +securitypolicyviolation, +webKitWillRevealBottom, +webKitWillRevealLeft, +webKitWillRevealRight, +webKitWillRevealTop, +getVisibilityState, +getHidden, +#if WEBKIT_CHECK_VERSION(1,10,0) +getSecurityPolicy, +#endif +#if WEBKIT_CHECK_VERSION(2,2,2) +getCurrentScript, +#endif +Document, +castToDocument, +gTypeDocument, +DocumentClass, +toDocument, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures +import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + + +createElement :: + (MonadIO m, DocumentClass self, GlibString string) => + self -> (Maybe string) -> m (Maybe Element) +createElement self tagName + = liftIO + (maybeNull (makeNewGObject mkElement) + (propagateGError $ + \ errorPtr_ -> + maybeWith withUTFString tagName $ + \ tagNamePtr -> + {# call webkit_dom_document_create_element #} (toDocument self) + tagNamePtr + errorPtr_)) + +createDocumentFragment :: + (MonadIO m, DocumentClass self) => + self -> m (Maybe DocumentFragment) +createDocumentFragment self + = liftIO + (maybeNull (makeNewGObject mkDocumentFragment) + ({# call webkit_dom_document_create_document_fragment #} + (toDocument self))) + +createTextNode :: + (MonadIO m, DocumentClass self, GlibString string) => + self -> string -> m (Maybe Text) +createTextNode self data' + = liftIO + (maybeNull (makeNewGObject mkText) + (withUTFString data' $ + \ dataPtr -> + {# call webkit_dom_document_create_text_node #} (toDocument self) + dataPtr)) + +createComment :: + (MonadIO m, DocumentClass self, GlibString string) => + self -> string -> m (Maybe Comment) +createComment self data' + = liftIO + (maybeNull (makeNewGObject mkComment) + (withUTFString data' $ + \ dataPtr -> + {# call webkit_dom_document_create_comment #} (toDocument self) + dataPtr)) + +createCDATASection :: + (MonadIO m, DocumentClass self, GlibString string) => + self -> string -> m (Maybe CDATASection) +createCDATASection self data' + = liftIO + (maybeNull (makeNewGObject mkCDATASection) + (propagateGError $ + \ errorPtr_ -> + withUTFString data' $ + \ dataPtr -> + {# call webkit_dom_document_create_cdata_section #} + (toDocument self) + dataPtr + errorPtr_)) + +createProcessingInstruction :: + (MonadIO m, DocumentClass self, GlibString string) => + self -> string -> string -> m (Maybe ProcessingInstruction) +createProcessingInstruction self target data' + = liftIO + (maybeNull (makeNewGObject mkProcessingInstruction) + (propagateGError $ + \ errorPtr_ -> + withUTFString data' $ + \ dataPtr -> + withUTFString target $ + \ targetPtr -> + {# call webkit_dom_document_create_processing_instruction #} + (toDocument self) + targetPtr + dataPtr + errorPtr_)) + +createAttribute :: + (MonadIO m, DocumentClass self, GlibString string) => + self -> string -> m (Maybe Attr) +createAttribute self name + = liftIO + (maybeNull (makeNewGObject mkAttr) + (propagateGError $ + \ errorPtr_ -> + withUTFString name $ + \ namePtr -> + {# call webkit_dom_document_create_attribute #} (toDocument self) + namePtr + errorPtr_)) + +createEntityReference :: + (MonadIO m, DocumentClass self, GlibString string) => + self -> string -> m (Maybe EntityReference) +createEntityReference self name + = liftIO + (maybeNull (makeNewGObject mkEntityReference) + (propagateGError $ + \ errorPtr_ -> + withUTFString name $ + \ namePtr -> + {# call webkit_dom_document_create_entity_reference #} + (toDocument self) + namePtr + errorPtr_)) + +getElementsByTagName :: + (MonadIO m, DocumentClass self, GlibString string) => + self -> string -> m (Maybe NodeList) +getElementsByTagName self tagname + = liftIO + (maybeNull (makeNewGObject mkNodeList) + (withUTFString tagname $ + \ tagnamePtr -> + {# call webkit_dom_document_get_elements_by_tag_name #} + (toDocument self) + tagnamePtr)) + +importNode :: + (MonadIO m, DocumentClass self, NodeClass importedNode) => + self -> Maybe importedNode -> Bool -> m (Maybe Node) +importNode self importedNode deep + = liftIO + (maybeNull (makeNewGObject mkNode) + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_document_import_node #} (toDocument self) + (maybe (Node nullForeignPtr) toNode importedNode) + (fromBool deep) + errorPtr_)) + +createElementNS :: + (MonadIO m, DocumentClass self, GlibString string) => + self -> (Maybe string) -> (Maybe string) -> m (Maybe Element) +createElementNS self namespaceURI qualifiedName + = liftIO + (maybeNull (makeNewGObject mkElement) + (propagateGError $ + \ errorPtr_ -> + maybeWith withUTFString qualifiedName $ + \ qualifiedNamePtr -> + maybeWith withUTFString namespaceURI $ + \ namespaceURIPtr -> + {# call webkit_dom_document_create_element_ns #} (toDocument self) + namespaceURIPtr + qualifiedNamePtr + errorPtr_)) + +createAttributeNS :: + (MonadIO m, DocumentClass self, GlibString string) => + self -> (Maybe string) -> (Maybe string) -> m (Maybe Attr) +createAttributeNS self namespaceURI qualifiedName + = liftIO + (maybeNull (makeNewGObject mkAttr) + (propagateGError $ + \ errorPtr_ -> + maybeWith withUTFString qualifiedName $ + \ qualifiedNamePtr -> + maybeWith withUTFString namespaceURI $ + \ namespaceURIPtr -> + {# call webkit_dom_document_create_attribute_ns #} + (toDocument self) + namespaceURIPtr + qualifiedNamePtr + errorPtr_)) + +getElementsByTagNameNS :: + (MonadIO m, DocumentClass self, GlibString string) => + self -> (Maybe string) -> string -> m (Maybe NodeList) +getElementsByTagNameNS self namespaceURI localName + = liftIO + (maybeNull (makeNewGObject mkNodeList) + (withUTFString localName $ + \ localNamePtr -> + maybeWith withUTFString namespaceURI $ + \ namespaceURIPtr -> + {# call webkit_dom_document_get_elements_by_tag_name_ns #} + (toDocument self) + namespaceURIPtr + localNamePtr)) + +getElementById :: + (MonadIO m, DocumentClass self, GlibString string) => + self -> string -> m (Maybe Element) +getElementById self elementId + = liftIO + (maybeNull (makeNewGObject mkElement) + (withUTFString elementId $ + \ elementIdPtr -> + {# call webkit_dom_document_get_element_by_id #} (toDocument self) + elementIdPtr)) + +adoptNode :: + (MonadIO m, DocumentClass self, NodeClass source) => + self -> Maybe source -> m (Maybe Node) +adoptNode self source + = liftIO + (maybeNull (makeNewGObject mkNode) + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_document_adopt_node #} (toDocument self) + (maybe (Node nullForeignPtr) toNode source) + errorPtr_)) + +createEvent :: + (MonadIO m, DocumentClass self, GlibString string) => + self -> string -> m (Maybe Event) +createEvent self eventType + = liftIO + (maybeNull (makeNewGObject mkEvent) + (propagateGError $ + \ errorPtr_ -> + withUTFString eventType $ + \ eventTypePtr -> + {# call webkit_dom_document_create_event #} (toDocument self) + eventTypePtr + errorPtr_)) + +createRange :: + (MonadIO m, DocumentClass self) => self -> m (Maybe Range) +createRange self + = liftIO + (maybeNull (makeNewGObject mkRange) + ({# call webkit_dom_document_create_range #} (toDocument self))) + +createNodeIterator :: + (MonadIO m, DocumentClass self, NodeClass root, + NodeFilterClass filter) => + self -> + Maybe root -> + Word -> Maybe filter -> Bool -> m (Maybe NodeIterator) +createNodeIterator self root whatToShow filter + expandEntityReferences + = liftIO + (maybeNull (makeNewGObject mkNodeIterator) + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_document_create_node_iterator #} + (toDocument self) + (maybe (Node nullForeignPtr) toNode root) + (fromIntegral whatToShow) + (maybe (NodeFilter nullForeignPtr) toNodeFilter filter) + (fromBool expandEntityReferences) + errorPtr_)) + +createTreeWalker :: + (MonadIO m, DocumentClass self, NodeClass root, + NodeFilterClass filter) => + self -> + Maybe root -> Word -> Maybe filter -> Bool -> m (Maybe TreeWalker) +createTreeWalker self root whatToShow filter expandEntityReferences + = liftIO + (maybeNull (makeNewGObject mkTreeWalker) + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_document_create_tree_walker #} (toDocument self) + (maybe (Node nullForeignPtr) toNode root) + (fromIntegral whatToShow) + (maybe (NodeFilter nullForeignPtr) toNodeFilter filter) + (fromBool expandEntityReferences) + errorPtr_)) + +getOverrideStyle :: + (MonadIO m, DocumentClass self, ElementClass element, + GlibString string) => + self -> Maybe element -> string -> m (Maybe CSSStyleDeclaration) +getOverrideStyle self element pseudoElement + = liftIO + (maybeNull (makeNewGObject mkCSSStyleDeclaration) + (withUTFString pseudoElement $ + \ pseudoElementPtr -> + {# call webkit_dom_document_get_override_style #} (toDocument self) + (maybe (Element nullForeignPtr) toElement element) + pseudoElementPtr)) + +createExpression :: + (MonadIO m, DocumentClass self, XPathNSResolverClass resolver, + GlibString string) => + self -> string -> Maybe resolver -> m (Maybe XPathExpression) +createExpression self expression resolver + = liftIO + (maybeNull (makeNewGObject mkXPathExpression) + (propagateGError $ + \ errorPtr_ -> + withUTFString expression $ + \ expressionPtr -> + {# call webkit_dom_document_create_expression #} (toDocument self) + expressionPtr + (maybe (XPathNSResolver nullForeignPtr) toXPathNSResolver resolver) + errorPtr_)) + +createNSResolver :: + (MonadIO m, DocumentClass self, NodeClass nodeResolver) => + self -> Maybe nodeResolver -> m (Maybe XPathNSResolver) +createNSResolver self nodeResolver + = liftIO + (maybeNull (makeNewGObject mkXPathNSResolver) + ({# call webkit_dom_document_create_ns_resolver #} + (toDocument self) + (maybe (Node nullForeignPtr) toNode nodeResolver))) + +evaluate :: + (MonadIO m, DocumentClass self, NodeClass contextNode, + XPathNSResolverClass resolver, XPathResultClass inResult, + GlibString string) => + self -> + string -> + Maybe contextNode -> + Maybe resolver -> Word -> Maybe inResult -> m (Maybe XPathResult) +evaluate self expression contextNode resolver type' inResult + = liftIO + (maybeNull (makeNewGObject mkXPathResult) + (propagateGError $ + \ errorPtr_ -> + withUTFString expression $ + \ expressionPtr -> + {# call webkit_dom_document_evaluate #} (toDocument self) + expressionPtr + (maybe (Node nullForeignPtr) toNode contextNode) + (maybe (XPathNSResolver nullForeignPtr) toXPathNSResolver resolver) + (fromIntegral type') + (maybe (XPathResult nullForeignPtr) toXPathResult inResult) + errorPtr_)) + +execCommand :: + (MonadIO m, DocumentClass self, GlibString string) => + self -> string -> Bool -> (Maybe string) -> m Bool +execCommand self command userInterface value + = liftIO + (toBool <$> + (maybeWith withUTFString value $ + \ valuePtr -> + withUTFString command $ + \ commandPtr -> + {# call webkit_dom_document_exec_command #} (toDocument self) + commandPtr + (fromBool userInterface) + valuePtr)) + +queryCommandEnabled :: + (MonadIO m, DocumentClass self, GlibString string) => + self -> string -> m Bool +queryCommandEnabled self command + = liftIO + (toBool <$> + (withUTFString command $ + \ commandPtr -> + {# call webkit_dom_document_query_command_enabled #} + (toDocument self) + commandPtr)) + +queryCommandIndeterm :: + (MonadIO m, DocumentClass self, GlibString string) => + self -> string -> m Bool +queryCommandIndeterm self command + = liftIO + (toBool <$> + (withUTFString command $ + \ commandPtr -> + {# call webkit_dom_document_query_command_indeterm #} + (toDocument self) + commandPtr)) + +queryCommandState :: + (MonadIO m, DocumentClass self, GlibString string) => + self -> string -> m Bool +queryCommandState self command + = liftIO + (toBool <$> + (withUTFString command $ + \ commandPtr -> + {# call webkit_dom_document_query_command_state #} + (toDocument self) + commandPtr)) + +queryCommandSupported :: + (MonadIO m, DocumentClass self, GlibString string) => + self -> string -> m Bool +queryCommandSupported self command + = liftIO + (toBool <$> + (withUTFString command $ + \ commandPtr -> + {# call webkit_dom_document_query_command_supported #} + (toDocument self) + commandPtr)) + +queryCommandValue :: + (MonadIO m, DocumentClass self, GlibString string) => + self -> string -> m string +queryCommandValue self command + = liftIO + ((withUTFString command $ + \ commandPtr -> + {# call webkit_dom_document_query_command_value #} + (toDocument self) + commandPtr) + >>= + readUTFString) + +getElementsByName :: + (MonadIO m, DocumentClass self, GlibString string) => + self -> string -> m (Maybe NodeList) +getElementsByName self elementName + = liftIO + (maybeNull (makeNewGObject mkNodeList) + (withUTFString elementName $ + \ elementNamePtr -> + {# call webkit_dom_document_get_elements_by_name #} + (toDocument self) + elementNamePtr)) + +elementFromPoint :: + (MonadIO m, DocumentClass self) => + self -> Int -> Int -> m (Maybe Element) +elementFromPoint self x y + = liftIO + (maybeNull (makeNewGObject mkElement) + ({# call webkit_dom_document_element_from_point #} + (toDocument self) + (fromIntegral x) + (fromIntegral y))) + +caretRangeFromPoint :: + (MonadIO m, DocumentClass self) => + self -> Int -> Int -> m (Maybe Range) +caretRangeFromPoint self x y + = liftIO + (maybeNull (makeNewGObject mkRange) + ({# call webkit_dom_document_caret_range_from_point #} + (toDocument self) + (fromIntegral x) + (fromIntegral y))) + +createCSSStyleDeclaration :: + (MonadIO m, DocumentClass self) => + self -> m (Maybe CSSStyleDeclaration) +createCSSStyleDeclaration self + = liftIO + (maybeNull (makeNewGObject mkCSSStyleDeclaration) + ({# call webkit_dom_document_create_css_style_declaration #} + (toDocument self))) + +getElementsByClassName :: + (MonadIO m, DocumentClass self, GlibString string) => + self -> string -> m (Maybe NodeList) +getElementsByClassName self tagname + = liftIO + (maybeNull (makeNewGObject mkNodeList) + (withUTFString tagname $ + \ tagnamePtr -> + {# call webkit_dom_document_get_elements_by_class_name #} + (toDocument self) + tagnamePtr)) + +#if WEBKIT_CHECK_VERSION(2,5,1) +hasFocus :: (MonadIO m, DocumentClass self) => self -> m Bool +hasFocus self + = liftIO + (toBool <$> + ({# call webkit_dom_document_has_focus #} (toDocument self))) +#endif + +querySelector :: + (MonadIO m, DocumentClass self, GlibString string) => + self -> string -> m (Maybe Element) +querySelector self selectors + = liftIO + (maybeNull (makeNewGObject mkElement) + (propagateGError $ + \ errorPtr_ -> + withUTFString selectors $ + \ selectorsPtr -> + {# call webkit_dom_document_query_selector #} (toDocument self) + selectorsPtr + errorPtr_)) + +querySelectorAll :: + (MonadIO m, DocumentClass self, GlibString string) => + self -> string -> m (Maybe NodeList) +querySelectorAll self selectors + = liftIO + (maybeNull (makeNewGObject mkNodeList) + (propagateGError $ + \ errorPtr_ -> + withUTFString selectors $ + \ selectorsPtr -> + {# call webkit_dom_document_query_selector_all #} (toDocument self) + selectorsPtr + errorPtr_)) + +webkitCancelFullScreen :: + (MonadIO m, DocumentClass self) => self -> m () +webkitCancelFullScreen self + = liftIO + ({# call webkit_dom_document_webkit_cancel_full_screen #} + (toDocument self)) + +#if WEBKIT_CHECK_VERSION(2,2,2) +webkitExitFullscreen :: + (MonadIO m, DocumentClass self) => self -> m () +webkitExitFullscreen self + = liftIO + ({# call webkit_dom_document_webkit_exit_fullscreen #} + (toDocument self)) + +webkitGetNamedFlows :: + (MonadIO m, DocumentClass self) => + self -> m (Maybe DOMNamedFlowCollection) +webkitGetNamedFlows self + = liftIO + (maybeNull (makeNewGObject mkDOMNamedFlowCollection) + ({# call webkit_dom_document_webkit_get_named_flows #} + (toDocument self))) +#endif + +#if WEBKIT_CHECK_VERSION(2,4,2) +createTouch :: + (MonadIO m, DocumentClass self, WindowClass window, + EventTargetClass target) => + self -> + Maybe window -> + Maybe target -> + Int -> + Int -> + Int -> + Int -> Int -> Int -> Int -> Float -> Float -> m (Maybe Touch) +createTouch self window target identifier pageX pageY screenX + screenY webkitRadiusX webkitRadiusY webkitRotationAngle webkitForce + = liftIO + (maybeNull (makeNewGObject mkTouch) + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_document_create_touch #} (toDocument self) + (maybe (Window nullForeignPtr) toWindow window) + (maybe (EventTarget nullForeignPtr) toEventTarget target) + (fromIntegral identifier) + (fromIntegral pageX) + (fromIntegral pageY) + (fromIntegral screenX) + (fromIntegral screenY) + (fromIntegral webkitRadiusX) + (fromIntegral webkitRadiusY) + (realToFrac webkitRotationAngle) + (realToFrac webkitForce) + errorPtr_)) +#endif + +getDoctype :: + (MonadIO m, DocumentClass self) => self -> m (Maybe DocumentType) +getDoctype self + = liftIO + (maybeNull (makeNewGObject mkDocumentType) + ({# call webkit_dom_document_get_doctype #} (toDocument self))) + +getImplementation :: + (MonadIO m, DocumentClass self) => + self -> m (Maybe DOMImplementation) +getImplementation self + = liftIO + (maybeNull (makeNewGObject mkDOMImplementation) + ({# call webkit_dom_document_get_implementation #} + (toDocument self))) + +getDocumentElement :: + (MonadIO m, DocumentClass self) => self -> m (Maybe Element) +getDocumentElement self + = liftIO + (maybeNull (makeNewGObject mkElement) + ({# call webkit_dom_document_get_document_element #} + (toDocument self))) + +getInputEncoding :: + (MonadIO m, DocumentClass self, GlibString string) => + self -> m (Maybe string) +getInputEncoding self + = liftIO + (({# call webkit_dom_document_get_input_encoding #} + (toDocument self)) + >>= + maybePeek readUTFString) + +getXmlEncoding :: + (MonadIO m, DocumentClass self, GlibString string) => + self -> m (Maybe string) +getXmlEncoding self + = liftIO + (({# call webkit_dom_document_get_xml_encoding #} + (toDocument self)) + >>= + maybePeek readUTFString) + +setXmlVersion :: + (MonadIO m, DocumentClass self, GlibString string) => + self -> (Maybe string) -> m () +setXmlVersion self val + = liftIO + (propagateGError $ + \ errorPtr_ -> + maybeWith withUTFString val $ + \ valPtr -> + {# call webkit_dom_document_set_xml_version #} (toDocument self) + valPtr + errorPtr_) + +getXmlVersion :: + (MonadIO m, DocumentClass self, GlibString string) => + self -> m (Maybe string) +getXmlVersion self + = liftIO + (({# call webkit_dom_document_get_xml_version #} (toDocument self)) + >>= + maybePeek readUTFString) + +setXmlStandalone :: + (MonadIO m, DocumentClass self) => self -> Bool -> m () +setXmlStandalone self val + = liftIO + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_document_set_xml_standalone #} (toDocument self) + (fromBool val) + errorPtr_) + +getXmlStandalone :: + (MonadIO m, DocumentClass self) => self -> m Bool +getXmlStandalone self + = liftIO + (toBool <$> + ({# call webkit_dom_document_get_xml_standalone #} + (toDocument self))) + +getDocumentURI :: + (MonadIO m, DocumentClass self, GlibString string) => + self -> m (Maybe string) +getDocumentURI self + = liftIO + (({# call webkit_dom_document_get_document_uri #} + (toDocument self)) + >>= + maybePeek readUTFString) + +getDefaultView :: + (MonadIO m, DocumentClass self) => self -> m (Maybe Window) +getDefaultView self + = liftIO + (maybeNull (makeNewGObject mkWindow) + ({# call webkit_dom_document_get_default_view #} + (toDocument self))) + +getStyleSheets :: + (MonadIO m, DocumentClass self) => self -> m (Maybe StyleSheetList) +getStyleSheets self + = liftIO + (maybeNull (makeNewGObject mkStyleSheetList) + ({# call webkit_dom_document_get_style_sheets #} + (toDocument self))) + +setTitle :: + (MonadIO m, DocumentClass self, GlibString string) => + self -> (Maybe string) -> m () +setTitle self val + = liftIO + (maybeWith withUTFString val $ + \ valPtr -> + {# call webkit_dom_document_set_title #} (toDocument self) valPtr) + +getTitle :: + (MonadIO m, DocumentClass self, GlibString string) => + self -> m (Maybe string) +getTitle self + = liftIO + (({# call webkit_dom_document_get_title #} (toDocument self)) >>= + maybePeek readUTFString) + +getReferrer :: + (MonadIO m, DocumentClass self, GlibString string) => + self -> m string +getReferrer self + = liftIO + (({# call webkit_dom_document_get_referrer #} (toDocument self)) + >>= + readUTFString) + +getDomain :: + (MonadIO m, DocumentClass self, GlibString string) => + self -> m string +getDomain self + = liftIO + (({# call webkit_dom_document_get_domain #} (toDocument self)) >>= + readUTFString) + +setCookie :: + (MonadIO m, DocumentClass self, GlibString string) => + self -> (Maybe string) -> m () +setCookie self val + = liftIO + (propagateGError $ + \ errorPtr_ -> + maybeWith withUTFString val $ + \ valPtr -> + {# call webkit_dom_document_set_cookie #} (toDocument self) valPtr + errorPtr_) + +getCookie :: + (MonadIO m, DocumentClass self, GlibString string) => + self -> m (Maybe string) +getCookie self + = liftIO + ((propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_document_get_cookie #} (toDocument self) + errorPtr_) + >>= + maybePeek readUTFString) + +setBody :: + (MonadIO m, HTMLElementClass val, DocumentClass self) => + self -> Maybe val -> m () +setBody self val + = liftIO + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_document_set_body #} (toDocument self) + (maybe (HTMLElement nullForeignPtr) toHTMLElement val) + errorPtr_) + +getBody :: + (MonadIO m, DocumentClass self) => self -> m (Maybe HTMLElement) +getBody self + = liftIO + (maybeNull (makeNewGObject mkHTMLElement) + ({# call webkit_dom_document_get_body #} (toDocument self))) + +getHead :: + (MonadIO m, DocumentClass self) => + self -> m (Maybe HTMLHeadElement) +getHead self + = liftIO + (maybeNull (makeNewGObject mkHTMLHeadElement) + ({# call webkit_dom_document_get_head #} (toDocument self))) + +getImages :: + (MonadIO m, DocumentClass self) => self -> m (Maybe HTMLCollection) +getImages self + = liftIO + (maybeNull (makeNewGObject mkHTMLCollection) + ({# call webkit_dom_document_get_images #} (toDocument self))) + +getApplets :: + (MonadIO m, DocumentClass self) => self -> m (Maybe HTMLCollection) +getApplets self + = liftIO + (maybeNull (makeNewGObject mkHTMLCollection) + ({# call webkit_dom_document_get_applets #} (toDocument self))) + +getLinks :: + (MonadIO m, DocumentClass self) => self -> m (Maybe HTMLCollection) +getLinks self + = liftIO + (maybeNull (makeNewGObject mkHTMLCollection) + ({# call webkit_dom_document_get_links #} (toDocument self))) + +getForms :: + (MonadIO m, DocumentClass self) => self -> m (Maybe HTMLCollection) +getForms self + = liftIO + (maybeNull (makeNewGObject mkHTMLCollection) + ({# call webkit_dom_document_get_forms #} (toDocument self))) + +getAnchors :: + (MonadIO m, DocumentClass self) => self -> m (Maybe HTMLCollection) +getAnchors self + = liftIO + (maybeNull (makeNewGObject mkHTMLCollection) + ({# call webkit_dom_document_get_anchors #} (toDocument self))) + +getLastModified :: + (MonadIO m, DocumentClass self, GlibString string) => + self -> m string +getLastModified self + = liftIO + (({# call webkit_dom_document_get_last_modified #} + (toDocument self)) + >>= + readUTFString) + +setCharset :: + (MonadIO m, DocumentClass self, GlibString string) => + self -> (Maybe string) -> m () +setCharset self val + = liftIO + (maybeWith withUTFString val $ + \ valPtr -> + {# call webkit_dom_document_set_charset #} (toDocument self) + valPtr) + +getCharset :: + (MonadIO m, DocumentClass self, GlibString string) => + self -> m (Maybe string) +getCharset self + = liftIO + (({# call webkit_dom_document_get_charset #} (toDocument self)) >>= + maybePeek readUTFString) + +getDefaultCharset :: + (MonadIO m, DocumentClass self, GlibString string) => + self -> m (Maybe string) +getDefaultCharset self + = liftIO + (({# call webkit_dom_document_get_default_charset #} + (toDocument self)) + >>= + maybePeek readUTFString) + +getReadyState :: + (MonadIO m, DocumentClass self, GlibString string) => + self -> m (Maybe string) +getReadyState self + = liftIO + (({# call webkit_dom_document_get_ready_state #} (toDocument self)) + >>= + maybePeek readUTFString) + +getCharacterSet :: + (MonadIO m, DocumentClass self, GlibString string) => + self -> m (Maybe string) +getCharacterSet self + = liftIO + (({# call webkit_dom_document_get_character_set #} + (toDocument self)) + >>= + maybePeek readUTFString) + +getPreferredStylesheetSet :: + (MonadIO m, DocumentClass self, GlibString string) => + self -> m (Maybe string) +getPreferredStylesheetSet self + = liftIO + (({# call webkit_dom_document_get_preferred_stylesheet_set #} + (toDocument self)) + >>= + maybePeek readUTFString) + +setSelectedStylesheetSet :: + (MonadIO m, DocumentClass self, GlibString string) => + self -> (Maybe string) -> m () +setSelectedStylesheetSet self val + = liftIO + (maybeWith withUTFString val $ + \ valPtr -> + {# call webkit_dom_document_set_selected_stylesheet_set #} + (toDocument self) + valPtr) + +getSelectedStylesheetSet :: + (MonadIO m, DocumentClass self, GlibString string) => + self -> m (Maybe string) +getSelectedStylesheetSet self + = liftIO + (({# call webkit_dom_document_get_selected_stylesheet_set #} + (toDocument self)) + >>= + maybePeek readUTFString) + +getCompatMode :: + (MonadIO m, DocumentClass self, GlibString string) => + self -> m string +getCompatMode self + = liftIO + (({# call webkit_dom_document_get_compat_mode #} (toDocument self)) + >>= + readUTFString) + +getWebkitIsFullScreen :: + (MonadIO m, DocumentClass self) => self -> m Bool +getWebkitIsFullScreen self + = liftIO + (toBool <$> + ({# call webkit_dom_document_get_webkit_is_full_screen #} + (toDocument self))) + +getWebkitFullScreenKeyboardInputAllowed :: + (MonadIO m, DocumentClass self) => self -> m Bool +getWebkitFullScreenKeyboardInputAllowed self + = liftIO + (toBool <$> + ({# call + webkit_dom_document_get_webkit_full_screen_keyboard_input_allowed + #} + (toDocument self))) + +getWebkitCurrentFullScreenElement :: + (MonadIO m, DocumentClass self) => self -> m (Maybe Element) +getWebkitCurrentFullScreenElement self + = liftIO + (maybeNull (makeNewGObject mkElement) + ({# call webkit_dom_document_get_webkit_current_full_screen_element + #} + (toDocument self))) + +#if WEBKIT_CHECK_VERSION(2,2,2) +getWebkitFullscreenEnabled :: + (MonadIO m, DocumentClass self) => self -> m Bool +getWebkitFullscreenEnabled self + = liftIO + (toBool <$> + ({# call webkit_dom_document_get_webkit_fullscreen_enabled #} + (toDocument self))) + +getWebkitFullscreenElement :: + (MonadIO m, DocumentClass self) => self -> m (Maybe Element) +getWebkitFullscreenElement self + = liftIO + (maybeNull (makeNewGObject mkElement) + ({# call webkit_dom_document_get_webkit_fullscreen_element #} + (toDocument self))) +#endif + +abort :: (DocumentClass self) => EventName self UIEvent +abort = EventName "abort" + +blur :: (DocumentClass self) => EventName self UIEvent +blur = EventName "blur" + +change :: (DocumentClass self) => EventName self Event +change = EventName "change" + +click :: (DocumentClass self) => EventName self MouseEvent +click = EventName "click" + +contextMenu :: (DocumentClass self) => EventName self MouseEvent +contextMenu = EventName "contextmenu" + +dblClick :: (DocumentClass self) => EventName self MouseEvent +dblClick = EventName "dblclick" + +drag :: (DocumentClass self) => EventName self MouseEvent +drag = EventName "drag" + +dragEnd :: (DocumentClass self) => EventName self MouseEvent +dragEnd = EventName "dragend" + +dragEnter :: (DocumentClass self) => EventName self MouseEvent +dragEnter = EventName "dragenter" + +dragLeave :: (DocumentClass self) => EventName self MouseEvent +dragLeave = EventName "dragleave" + +dragOver :: (DocumentClass self) => EventName self MouseEvent +dragOver = EventName "dragover" + +dragStart :: (DocumentClass self) => EventName self MouseEvent +dragStart = EventName "dragstart" + +drop :: (DocumentClass self) => EventName self MouseEvent +drop = EventName "drop" + +error :: (DocumentClass self) => EventName self UIEvent +error = EventName "error" + +focus :: (DocumentClass self) => EventName self UIEvent +focus = EventName "focus" + +input :: (DocumentClass self) => EventName self Event +input = EventName "input" + +invalid :: (DocumentClass self) => EventName self Event +invalid = EventName "invalid" + +#if WEBKIT_CHECK_VERSION(2,2,2) +keyDown :: (DocumentClass self) => EventName self KeyboardEvent +keyDown = EventName "keydown" + +keyPress :: (DocumentClass self) => EventName self KeyboardEvent +keyPress = EventName "keypress" + +keyUp :: (DocumentClass self) => EventName self KeyboardEvent +keyUp = EventName "keyup" +#endif + +load :: (DocumentClass self) => EventName self UIEvent +load = EventName "load" + +mouseDown :: (DocumentClass self) => EventName self MouseEvent +mouseDown = EventName "mousedown" + +mouseEnter :: (DocumentClass self) => EventName self MouseEvent +mouseEnter = EventName "mouseenter" + +mouseLeave :: (DocumentClass self) => EventName self MouseEvent +mouseLeave = EventName "mouseleave" + +mouseMove :: (DocumentClass self) => EventName self MouseEvent +mouseMove = EventName "mousemove" + +mouseOut :: (DocumentClass self) => EventName self MouseEvent +mouseOut = EventName "mouseout" + +mouseOver :: (DocumentClass self) => EventName self MouseEvent +mouseOver = EventName "mouseover" + +mouseUp :: (DocumentClass self) => EventName self MouseEvent +mouseUp = EventName "mouseup" + +mouseWheel :: (DocumentClass self) => EventName self MouseEvent +mouseWheel = EventName "mousewheel" + +readyStateChange :: (DocumentClass self) => EventName self Event +readyStateChange = EventName "readystatechange" + +scroll :: (DocumentClass self) => EventName self UIEvent +scroll = EventName "scroll" + +select :: (DocumentClass self) => EventName self UIEvent +select = EventName "select" + +submit :: (DocumentClass self) => EventName self Event +submit = EventName "submit" + +#if WEBKIT_CHECK_VERSION(2,4,0) +wheel :: (DocumentClass self) => EventName self WheelEvent +wheel = EventName "wheel" +#endif + +beforeCut :: (DocumentClass self) => EventName self Event +beforeCut = EventName "beforecut" + +cut :: (DocumentClass self) => EventName self Event +cut = EventName "cut" + +beforeCopy :: (DocumentClass self) => EventName self Event +beforeCopy = EventName "beforecopy" + +copy :: (DocumentClass self) => EventName self Event +copy = EventName "copy" + +beforePaste :: (DocumentClass self) => EventName self Event +beforePaste = EventName "beforepaste" + +paste :: (DocumentClass self) => EventName self Event +paste = EventName "paste" + +reset :: (DocumentClass self) => EventName self Event +reset = EventName "reset" + +search :: (DocumentClass self) => EventName self Event +search = EventName "search" + +selectStart :: (DocumentClass self) => EventName self Event +selectStart = EventName "selectstart" + +selectionchange :: (DocumentClass self) => EventName self Event +selectionchange = EventName "selectionchange" + +touchStart :: (DocumentClass self) => EventName self UIEvent +touchStart = EventName "touchstart" + +touchMove :: (DocumentClass self) => EventName self UIEvent +touchMove = EventName "touchmove" + +touchEnd :: (DocumentClass self) => EventName self UIEvent +touchEnd = EventName "touchend" + +touchCancel :: (DocumentClass self) => EventName self UIEvent +touchCancel = EventName "touchcancel" + +webKitFullscreenChange :: + (DocumentClass self) => EventName self Event +webKitFullscreenChange = EventName "webkitfullscreenchange" + +webKitFullscreenError :: + (DocumentClass self) => EventName self Event +webKitFullscreenError = EventName "webkitfullscreenerror" + +pointerlockchange :: (DocumentClass self) => EventName self Event +pointerlockchange = EventName "pointerlockchange" + +pointerlockerror :: (DocumentClass self) => EventName self Event +pointerlockerror = EventName "pointerlockerror" + +securitypolicyviolation :: + (DocumentClass self) => EventName self Event +securitypolicyviolation = EventName "securitypolicyviolation" + +webKitWillRevealBottom :: + (DocumentClass self) => EventName self Event +webKitWillRevealBottom = EventName "webkitwillrevealbottom" + +webKitWillRevealLeft :: + (DocumentClass self) => EventName self Event +webKitWillRevealLeft = EventName "webkitwillrevealleft" + +webKitWillRevealRight :: + (DocumentClass self) => EventName self Event +webKitWillRevealRight = EventName "webkitwillrevealright" + +webKitWillRevealTop :: (DocumentClass self) => EventName self Event +webKitWillRevealTop = EventName "webkitwillrevealtop" + +getVisibilityState :: + (MonadIO m, DocumentClass self, GlibString string) => + self -> m string +getVisibilityState self + = liftIO +#if WEBKIT_CHECK_VERSION(2,2,2) + (({# call webkit_dom_document_get_visibility_state #} +#else + (({# call webkit_dom_document_get_webkit_visibility_state #} +#endif + (toDocument self)) + >>= + readUTFString) + +getHidden :: (MonadIO m, DocumentClass self) => self -> m Bool +getHidden self + = liftIO + (toBool <$> +#if WEBKIT_CHECK_VERSION(2,2,2) + ({# call webkit_dom_document_get_hidden #} (toDocument self))) +#else + ({# call webkit_dom_document_get_webkit_hidden #} (toDocument self))) +#endif + +#if WEBKIT_CHECK_VERSION(1,10,0) +getSecurityPolicy :: + (MonadIO m, DocumentClass self) => self -> m (Maybe SecurityPolicy) +getSecurityPolicy self + = liftIO + (maybeNull (makeNewGObject mkSecurityPolicy) + ({# call webkit_dom_document_get_security_policy #} + (toDocument self))) +#endif + +#if WEBKIT_CHECK_VERSION(2,2,2) +getCurrentScript :: + (MonadIO m, DocumentClass self) => + self -> m (Maybe HTMLScriptElement) +getCurrentScript self + = liftIO + (maybeNull (makeNewGObject mkHTMLScriptElement) + ({# call webkit_dom_document_get_current_script #} + (toDocument self))) #endif diff --git a/Graphics/UI/Gtk/WebKit/DOM/DocumentType.chs b/Graphics/UI/Gtk/WebKit/DOM/DocumentType.chs --- a/Graphics/UI/Gtk/WebKit/DOM/DocumentType.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/DocumentType.chs @@ -1,59 +1,85 @@ -module Graphics.UI.Gtk.WebKit.DOM.DocumentType - (documentTypeGetName, documentTypeGetEntities, - documentTypeGetNotations, documentTypeGetPublicId, - documentTypeGetSystemId, documentTypeGetInternalSubset, - DocumentType, DocumentTypeClass, castToDocumentType, - gTypeDocumentType, toDocumentType) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.DocumentType( +getName, +getEntities, +getNotations, +getPublicId, +getSystemId, +getInternalSubset, +DocumentType, +castToDocumentType, +gTypeDocumentType, +DocumentTypeClass, +toDocumentType, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -documentTypeGetName :: - (DocumentTypeClass self) => self -> IO String -documentTypeGetName self - = ({# call webkit_dom_document_type_get_name #} - (toDocumentType self)) - >>= - readUTFString +getName :: + (MonadIO m, DocumentTypeClass self, GlibString string) => + self -> m string +getName self + = liftIO + (({# call webkit_dom_document_type_get_name #} + (toDocumentType self)) + >>= + readUTFString) -documentTypeGetEntities :: - (DocumentTypeClass self) => self -> IO (Maybe NamedNodeMap) -documentTypeGetEntities self - = maybeNull (makeNewGObject mkNamedNodeMap) - ({# call webkit_dom_document_type_get_entities #} - (toDocumentType self)) +getEntities :: + (MonadIO m, DocumentTypeClass self) => + self -> m (Maybe NamedNodeMap) +getEntities self + = liftIO + (maybeNull (makeNewGObject mkNamedNodeMap) + ({# call webkit_dom_document_type_get_entities #} + (toDocumentType self))) -documentTypeGetNotations :: - (DocumentTypeClass self) => self -> IO (Maybe NamedNodeMap) -documentTypeGetNotations self - = maybeNull (makeNewGObject mkNamedNodeMap) - ({# call webkit_dom_document_type_get_notations #} - (toDocumentType self)) +getNotations :: + (MonadIO m, DocumentTypeClass self) => + self -> m (Maybe NamedNodeMap) +getNotations self + = liftIO + (maybeNull (makeNewGObject mkNamedNodeMap) + ({# call webkit_dom_document_type_get_notations #} + (toDocumentType self))) -documentTypeGetPublicId :: - (DocumentTypeClass self) => self -> IO String -documentTypeGetPublicId self - = ({# call webkit_dom_document_type_get_public_id #} - (toDocumentType self)) - >>= - readUTFString +getPublicId :: + (MonadIO m, DocumentTypeClass self, GlibString string) => + self -> m (Maybe string) +getPublicId self + = liftIO + (({# call webkit_dom_document_type_get_public_id #} + (toDocumentType self)) + >>= + maybePeek readUTFString) -documentTypeGetSystemId :: - (DocumentTypeClass self) => self -> IO String -documentTypeGetSystemId self - = ({# call webkit_dom_document_type_get_system_id #} - (toDocumentType self)) - >>= - readUTFString +getSystemId :: + (MonadIO m, DocumentTypeClass self, GlibString string) => + self -> m (Maybe string) +getSystemId self + = liftIO + (({# call webkit_dom_document_type_get_system_id #} + (toDocumentType self)) + >>= + maybePeek readUTFString) -documentTypeGetInternalSubset :: - (DocumentTypeClass self) => self -> IO String -documentTypeGetInternalSubset self - = ({# call webkit_dom_document_type_get_internal_subset #} - (toDocumentType self)) - >>= - readUTFString +getInternalSubset :: + (MonadIO m, DocumentTypeClass self, GlibString string) => + self -> m (Maybe string) +getInternalSubset self + = liftIO + (({# call webkit_dom_document_type_get_internal_subset #} + (toDocumentType self)) + >>= + maybePeek readUTFString) diff --git a/Graphics/UI/Gtk/WebKit/DOM/Element.chs b/Graphics/UI/Gtk/WebKit/DOM/Element.chs --- a/Graphics/UI/Gtk/WebKit/DOM/Element.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/Element.chs @@ -1,703 +1,971 @@ -module Graphics.UI.Gtk.WebKit.DOM.Element - (elementGetAttribute, elementSetAttribute, elementRemoveAttribute, - elementGetAttributeNode, elementSetAttributeNode, - elementRemoveAttributeNode, elementGetElementsByTagName, -#if WEBKIT_CHECK_VERSION(2,2,2) - elementHasAttributes, -#endif - elementGetAttributeNS, elementSetAttributeNS, - elementRemoveAttributeNS, elementGetElementsByTagNameNS, - elementGetAttributeNodeNS, elementSetAttributeNodeNS, - elementHasAttribute, elementHasAttributeNS, elementFocus, - elementBlur, elementScrollIntoView, elementScrollIntoViewIfNeeded, - elementScrollByLines, elementScrollByPages, - elementGetElementsByClassName, elementQuerySelector, - elementQuerySelectorAll, elementWebkitMatchesSelector, -#if WEBKIT_CHECK_VERSION(2,2,2) - elementWebkitRequestPointerLock, -#endif - elementGetTagName, -#if WEBKIT_CHECK_VERSION(2,2,2) - elementGetAttributes, -#endif - elementGetStyle, -#if WEBKIT_CHECK_VERSION(2,2,2) - elementSetId, elementGetId, -#endif - elementGetOffsetLeft, - elementGetOffsetTop, elementGetOffsetWidth, elementGetOffsetHeight, - elementGetOffsetParent, elementGetClientLeft, elementGetClientTop, - elementGetClientWidth, elementGetClientHeight, - elementSetScrollLeft, elementGetScrollLeft, elementSetScrollTop, - elementGetScrollTop, elementGetScrollWidth, elementGetScrollHeight, -#if WEBKIT_CHECK_VERSION(1,10,0) - elementSetClassName, elementGetClassName, elementGetClassList, -#endif - elementGetFirstElementChild, elementGetLastElementChild, - elementGetPreviousElementSibling, elementGetNextElementSibling, - elementGetChildElementCount, -#if WEBKIT_CHECK_VERSION(1,10,0) - elementGetWebkitRegionOverset, -#endif - elementOnabort, elementOnblur, elementOnchange, elementOnclick, - elementOncontextmenu, elementOndblclick, elementOndrag, - elementOndragend, elementOndragenter, elementOndragleave, - elementOndragover, elementOndragstart, elementOndrop, - elementOnerror, elementOnfocus, elementOninput, elementOninvalid, - elementOnkeydown, elementOnkeypress, elementOnkeyup, elementOnload, - elementOnmousedown, -#if WEBKIT_CHECK_VERSION(2,2,2) - elementOnmouseenter, elementOnmouseleave, -#endif - elementOnmousemove, elementOnmouseout, - elementOnmouseover, elementOnmouseup, elementOnmousewheel, - elementOnscroll, elementOnselect, elementOnsubmit, - elementOnbeforecut, elementOncut, elementOnbeforecopy, - elementOncopy, elementOnbeforepaste, elementOnpaste, - elementOnreset, elementOnsearch, elementOnselectstart, - elementOntouchstart, elementOntouchmove, elementOntouchend, - elementOntouchcancel, elementOnwebkitfullscreenchange, - elementOnwebkitfullscreenerror, - Element, ElementClass, castToElement, gTypeElement, toElement) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} -import System.Glib.GError -import Graphics.UI.Gtk.WebKit.DOM.EventM - -elementGetAttribute :: - (ElementClass self) => self -> String -> IO String -elementGetAttribute self name - = (withUTFString name $ - \ namePtr -> - {# call webkit_dom_element_get_attribute #} (toElement self) - namePtr) - >>= - readUTFString - -elementSetAttribute :: - (ElementClass self) => self -> String -> String -> IO () -elementSetAttribute self name value - = propagateGError $ - \ errorPtr_ -> - withUTFString value $ - \ valuePtr -> - withUTFString name $ - \ namePtr -> - {# call webkit_dom_element_set_attribute #} (toElement self) - namePtr - valuePtr - errorPtr_ - -elementRemoveAttribute :: - (ElementClass self) => self -> String -> IO () -elementRemoveAttribute self name - = withUTFString name $ - \ namePtr -> - {# call webkit_dom_element_remove_attribute #} (toElement self) - namePtr - -elementGetAttributeNode :: - (ElementClass self) => self -> String -> IO (Maybe DOMAttr) -elementGetAttributeNode self name - = maybeNull (makeNewGObject mkDOMAttr) - (withUTFString name $ - \ namePtr -> - {# call webkit_dom_element_get_attribute_node #} (toElement self) - namePtr) - -elementSetAttributeNode :: - (ElementClass self, DOMAttrClass newAttr) => - self -> Maybe newAttr -> IO (Maybe DOMAttr) -elementSetAttributeNode self newAttr - = maybeNull (makeNewGObject mkDOMAttr) - (propagateGError $ - \ errorPtr_ -> - {# call webkit_dom_element_set_attribute_node #} (toElement self) - (maybe (DOMAttr nullForeignPtr) toDOMAttr newAttr) - errorPtr_) - -elementRemoveAttributeNode :: - (ElementClass self, DOMAttrClass oldAttr) => - self -> Maybe oldAttr -> IO (Maybe DOMAttr) -elementRemoveAttributeNode self oldAttr - = maybeNull (makeNewGObject mkDOMAttr) - (propagateGError $ - \ errorPtr_ -> - {# call webkit_dom_element_remove_attribute_node #} - (toElement self) - (maybe (DOMAttr nullForeignPtr) toDOMAttr oldAttr) - errorPtr_) - -elementGetElementsByTagName :: - (ElementClass self) => self -> String -> IO (Maybe NodeList) -elementGetElementsByTagName self name - = maybeNull (makeNewGObject mkNodeList) - (withUTFString name $ - \ namePtr -> - {# call webkit_dom_element_get_elements_by_tag_name #} - (toElement self) - namePtr) - -#if WEBKIT_CHECK_VERSION(2,2,2) -elementHasAttributes :: (ElementClass self) => self -> IO Bool -elementHasAttributes self - = toBool <$> - ({# call webkit_dom_element_has_attributes #} (toElement self)) -#endif - -elementGetAttributeNS :: - (ElementClass self) => self -> String -> String -> IO String -elementGetAttributeNS self namespaceURI localName - = (withUTFString localName $ - \ localNamePtr -> - withUTFString namespaceURI $ - \ namespaceURIPtr -> - {# call webkit_dom_element_get_attribute_ns #} (toElement self) - namespaceURIPtr - localNamePtr) - >>= - readUTFString - -elementSetAttributeNS :: - (ElementClass self) => self -> String -> String -> String -> IO () -elementSetAttributeNS self namespaceURI qualifiedName value - = propagateGError $ - \ errorPtr_ -> - withUTFString value $ - \ valuePtr -> - withUTFString qualifiedName $ - \ qualifiedNamePtr -> - withUTFString namespaceURI $ - \ namespaceURIPtr -> - {# call webkit_dom_element_set_attribute_ns #} (toElement self) - namespaceURIPtr - qualifiedNamePtr - valuePtr - errorPtr_ - -elementRemoveAttributeNS :: - (ElementClass self) => self -> String -> String -> IO () -elementRemoveAttributeNS self namespaceURI localName - = withUTFString localName $ - \ localNamePtr -> - withUTFString namespaceURI $ - \ namespaceURIPtr -> - {# call webkit_dom_element_remove_attribute_ns #} (toElement self) - namespaceURIPtr - localNamePtr - -elementGetElementsByTagNameNS :: - (ElementClass self) => - self -> String -> String -> IO (Maybe NodeList) -elementGetElementsByTagNameNS self namespaceURI localName - = maybeNull (makeNewGObject mkNodeList) - (withUTFString localName $ - \ localNamePtr -> - withUTFString namespaceURI $ - \ namespaceURIPtr -> - {# call webkit_dom_element_get_elements_by_tag_name_ns #} - (toElement self) - namespaceURIPtr - localNamePtr) - -elementGetAttributeNodeNS :: - (ElementClass self) => - self -> String -> String -> IO (Maybe DOMAttr) -elementGetAttributeNodeNS self namespaceURI localName - = maybeNull (makeNewGObject mkDOMAttr) - (withUTFString localName $ - \ localNamePtr -> - withUTFString namespaceURI $ - \ namespaceURIPtr -> - {# call webkit_dom_element_get_attribute_node_ns #} - (toElement self) - namespaceURIPtr - localNamePtr) - -elementSetAttributeNodeNS :: - (ElementClass self, DOMAttrClass newAttr) => - self -> Maybe newAttr -> IO (Maybe DOMAttr) -elementSetAttributeNodeNS self newAttr - = maybeNull (makeNewGObject mkDOMAttr) - (propagateGError $ - \ errorPtr_ -> - {# call webkit_dom_element_set_attribute_node_ns #} - (toElement self) - (maybe (DOMAttr nullForeignPtr) toDOMAttr newAttr) - errorPtr_) - -elementHasAttribute :: - (ElementClass self) => self -> String -> IO Bool -elementHasAttribute self name - = toBool <$> - (withUTFString name $ - \ namePtr -> - {# call webkit_dom_element_has_attribute #} (toElement self) - namePtr) - -elementHasAttributeNS :: - (ElementClass self) => self -> String -> String -> IO Bool -elementHasAttributeNS self namespaceURI localName - = toBool <$> - (withUTFString localName $ - \ localNamePtr -> - withUTFString namespaceURI $ - \ namespaceURIPtr -> - {# call webkit_dom_element_has_attribute_ns #} (toElement self) - namespaceURIPtr - localNamePtr) - -elementFocus :: (ElementClass self) => self -> IO () -elementFocus self - = {# call webkit_dom_element_focus #} (toElement self) - -elementBlur :: (ElementClass self) => self -> IO () -elementBlur self - = {# call webkit_dom_element_blur #} (toElement self) - -elementScrollIntoView :: - (ElementClass self) => self -> Bool -> IO () -elementScrollIntoView self alignWithTop - = {# call webkit_dom_element_scroll_into_view #} (toElement self) - (fromBool alignWithTop) - -elementScrollIntoViewIfNeeded :: - (ElementClass self) => self -> Bool -> IO () -elementScrollIntoViewIfNeeded self centerIfNeeded - = {# call webkit_dom_element_scroll_into_view_if_needed #} - (toElement self) - (fromBool centerIfNeeded) - -elementScrollByLines :: (ElementClass self) => self -> Int -> IO () -elementScrollByLines self lines - = {# call webkit_dom_element_scroll_by_lines #} (toElement self) - (fromIntegral lines) - -elementScrollByPages :: (ElementClass self) => self -> Int -> IO () -elementScrollByPages self pages - = {# call webkit_dom_element_scroll_by_pages #} (toElement self) - (fromIntegral pages) - -elementGetElementsByClassName :: - (ElementClass self) => self -> String -> IO (Maybe NodeList) -elementGetElementsByClassName self name - = maybeNull (makeNewGObject mkNodeList) - (withUTFString name $ - \ namePtr -> - {# call webkit_dom_element_get_elements_by_class_name #} - (toElement self) - namePtr) - -elementQuerySelector :: - (ElementClass self) => self -> String -> IO (Maybe Element) -elementQuerySelector self selectors - = maybeNull (makeNewGObject mkElement) - (propagateGError $ - \ errorPtr_ -> - withUTFString selectors $ - \ selectorsPtr -> - {# call webkit_dom_element_query_selector #} (toElement self) - selectorsPtr - errorPtr_) - -elementQuerySelectorAll :: - (ElementClass self) => self -> String -> IO (Maybe NodeList) -elementQuerySelectorAll self selectors - = maybeNull (makeNewGObject mkNodeList) - (propagateGError $ - \ errorPtr_ -> - withUTFString selectors $ - \ selectorsPtr -> - {# call webkit_dom_element_query_selector_all #} (toElement self) - selectorsPtr - errorPtr_) - -elementWebkitMatchesSelector :: - (ElementClass self) => self -> String -> IO Bool -elementWebkitMatchesSelector self selectors - = toBool <$> - (propagateGError $ - \ errorPtr_ -> - withUTFString selectors $ - \ selectorsPtr -> - {# call webkit_dom_element_webkit_matches_selector #} - (toElement self) - selectorsPtr - errorPtr_) - -#if WEBKIT_CHECK_VERSION(2,2,2) -elementWebkitRequestPointerLock :: - (ElementClass self) => self -> IO () -elementWebkitRequestPointerLock self - = {# call webkit_dom_element_webkit_request_pointer_lock #} - (toElement self) -#endif - -elementGetTagName :: (ElementClass self) => self -> IO String -elementGetTagName self - = ({# call webkit_dom_element_get_tag_name #} (toElement self)) >>= - readUTFString - -#if WEBKIT_CHECK_VERSION(2,2,2) -elementGetAttributes :: - (ElementClass self) => self -> IO (Maybe NamedNodeMap) -elementGetAttributes self - = maybeNull (makeNewGObject mkNamedNodeMap) - ({# call webkit_dom_element_get_attributes #} (toElement self)) -#endif - -elementGetStyle :: - (ElementClass self) => self -> IO (Maybe CSSStyleDeclaration) -elementGetStyle self - = maybeNull (makeNewGObject mkCSSStyleDeclaration) - ({# call webkit_dom_element_get_style #} (toElement self)) - -#if WEBKIT_CHECK_VERSION(2,2,2) -elementSetId :: (ElementClass self) => self -> String -> IO () -elementSetId self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_element_set_id #} (toElement self) valPtr - -elementGetId :: (ElementClass self) => self -> IO String -elementGetId self - = ({# call webkit_dom_element_get_id #} (toElement self)) >>= - readUTFString -#endif - -elementGetOffsetLeft :: (ElementClass self) => self -> IO Int -elementGetOffsetLeft self - = fromIntegral <$> - ({# call webkit_dom_element_get_offset_left #} (toElement self)) - -elementGetOffsetTop :: (ElementClass self) => self -> IO Int -elementGetOffsetTop self - = fromIntegral <$> - ({# call webkit_dom_element_get_offset_top #} (toElement self)) - -elementGetOffsetWidth :: (ElementClass self) => self -> IO Int -elementGetOffsetWidth self - = fromIntegral <$> - ({# call webkit_dom_element_get_offset_width #} (toElement self)) - -elementGetOffsetHeight :: (ElementClass self) => self -> IO Int -elementGetOffsetHeight self - = fromIntegral <$> - ({# call webkit_dom_element_get_offset_height #} (toElement self)) - -elementGetOffsetParent :: - (ElementClass self) => self -> IO (Maybe Element) -elementGetOffsetParent self - = maybeNull (makeNewGObject mkElement) - ({# call webkit_dom_element_get_offset_parent #} (toElement self)) - -elementGetClientLeft :: (ElementClass self) => self -> IO Int -elementGetClientLeft self - = fromIntegral <$> - ({# call webkit_dom_element_get_client_left #} (toElement self)) - -elementGetClientTop :: (ElementClass self) => self -> IO Int -elementGetClientTop self - = fromIntegral <$> - ({# call webkit_dom_element_get_client_top #} (toElement self)) - -elementGetClientWidth :: (ElementClass self) => self -> IO Int -elementGetClientWidth self - = fromIntegral <$> - ({# call webkit_dom_element_get_client_width #} (toElement self)) - -elementGetClientHeight :: (ElementClass self) => self -> IO Int -elementGetClientHeight self - = fromIntegral <$> - ({# call webkit_dom_element_get_client_height #} (toElement self)) - -elementSetScrollLeft :: (ElementClass self) => self -> Int -> IO () -elementSetScrollLeft self val - = {# call webkit_dom_element_set_scroll_left #} (toElement self) - (fromIntegral val) - -elementGetScrollLeft :: (ElementClass self) => self -> IO Int -elementGetScrollLeft self - = fromIntegral <$> - ({# call webkit_dom_element_get_scroll_left #} (toElement self)) - -elementSetScrollTop :: (ElementClass self) => self -> Int -> IO () -elementSetScrollTop self val - = {# call webkit_dom_element_set_scroll_top #} (toElement self) - (fromIntegral val) - -elementGetScrollTop :: (ElementClass self) => self -> IO Int -elementGetScrollTop self - = fromIntegral <$> - ({# call webkit_dom_element_get_scroll_top #} (toElement self)) - -elementGetScrollWidth :: (ElementClass self) => self -> IO Int -elementGetScrollWidth self - = fromIntegral <$> - ({# call webkit_dom_element_get_scroll_width #} (toElement self)) - -elementGetScrollHeight :: (ElementClass self) => self -> IO Int -elementGetScrollHeight self - = fromIntegral <$> - ({# call webkit_dom_element_get_scroll_height #} (toElement self)) - -#if WEBKIT_CHECK_VERSION(1,10,0) -elementSetClassName :: - (ElementClass self) => self -> String -> IO () -elementSetClassName self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_element_set_class_name #} (toElement self) - valPtr - -elementGetClassName :: (ElementClass self) => self -> IO String -elementGetClassName self - = ({# call webkit_dom_element_get_class_name #} (toElement self)) - >>= - readUTFString - -elementGetClassList :: - (ElementClass self) => self -> IO (Maybe DOMTokenList) -elementGetClassList self - = maybeNull (makeNewGObject mkDOMTokenList) - ({# call webkit_dom_element_get_class_list #} (toElement self)) -#endif - -elementGetFirstElementChild :: - (ElementClass self) => self -> IO (Maybe Element) -elementGetFirstElementChild self - = maybeNull (makeNewGObject mkElement) - ({# call webkit_dom_element_get_first_element_child #} - (toElement self)) - -elementGetLastElementChild :: - (ElementClass self) => self -> IO (Maybe Element) -elementGetLastElementChild self - = maybeNull (makeNewGObject mkElement) - ({# call webkit_dom_element_get_last_element_child #} - (toElement self)) - -elementGetPreviousElementSibling :: - (ElementClass self) => self -> IO (Maybe Element) -elementGetPreviousElementSibling self - = maybeNull (makeNewGObject mkElement) - ({# call webkit_dom_element_get_previous_element_sibling #} - (toElement self)) - -elementGetNextElementSibling :: - (ElementClass self) => self -> IO (Maybe Element) -elementGetNextElementSibling self - = maybeNull (makeNewGObject mkElement) - ({# call webkit_dom_element_get_next_element_sibling #} - (toElement self)) - -elementGetChildElementCount :: - (ElementClass self) => self -> IO Word -elementGetChildElementCount self - = fromIntegral <$> - ({# call webkit_dom_element_get_child_element_count #} - (toElement self)) - -#if WEBKIT_CHECK_VERSION(1,10,0) -elementGetWebkitRegionOverset :: - (ElementClass self) => self -> IO String -elementGetWebkitRegionOverset self - = ({# call webkit_dom_element_get_webkit_region_overset #} - (toElement self)) - >>= - readUTFString -#endif - -elementOnabort :: - (ElementClass self) => Signal self (EventM UIEvent self ()) -elementOnabort = (connect "abort") - -elementOnblur :: - (ElementClass self) => Signal self (EventM UIEvent self ()) -elementOnblur = (connect "blur") - -elementOnchange :: - (ElementClass self) => Signal self (EventM UIEvent self ()) -elementOnchange = (connect "change") - -elementOnclick :: - (ElementClass self) => Signal self (EventM MouseEvent self ()) -elementOnclick = (connect "click") - -elementOncontextmenu :: - (ElementClass self) => Signal self (EventM MouseEvent self ()) -elementOncontextmenu = (connect "contextmenu") - -elementOndblclick :: - (ElementClass self) => Signal self (EventM MouseEvent self ()) -elementOndblclick = (connect "dblclick") - -elementOndrag :: - (ElementClass self) => Signal self (EventM MouseEvent self ()) -elementOndrag = (connect "drag") - -elementOndragend :: - (ElementClass self) => Signal self (EventM MouseEvent self ()) -elementOndragend = (connect "dragend") - -elementOndragenter :: - (ElementClass self) => Signal self (EventM MouseEvent self ()) -elementOndragenter = (connect "dragenter") - -elementOndragleave :: - (ElementClass self) => Signal self (EventM MouseEvent self ()) -elementOndragleave = (connect "dragleave") - -elementOndragover :: - (ElementClass self) => Signal self (EventM MouseEvent self ()) -elementOndragover = (connect "dragover") - -elementOndragstart :: - (ElementClass self) => Signal self (EventM MouseEvent self ()) -elementOndragstart = (connect "dragstart") - -elementOndrop :: - (ElementClass self) => Signal self (EventM MouseEvent self ()) -elementOndrop = (connect "drop") - -elementOnerror :: - (ElementClass self) => Signal self (EventM UIEvent self ()) -elementOnerror = (connect "error") - -elementOnfocus :: - (ElementClass self) => Signal self (EventM UIEvent self ()) -elementOnfocus = (connect "focus") - -elementOninput :: - (ElementClass self) => Signal self (EventM UIEvent self ()) -elementOninput = (connect "input") - -elementOninvalid :: - (ElementClass self) => Signal self (EventM UIEvent self ()) -elementOninvalid = (connect "invalid") - -elementOnkeydown :: - (ElementClass self) => Signal self (EventM UIEvent self ()) -elementOnkeydown = (connect "keydown") - -elementOnkeypress :: - (ElementClass self) => Signal self (EventM UIEvent self ()) -elementOnkeypress = (connect "keypress") - -elementOnkeyup :: - (ElementClass self) => Signal self (EventM UIEvent self ()) -elementOnkeyup = (connect "keyup") - -elementOnload :: - (ElementClass self) => Signal self (EventM UIEvent self ()) -elementOnload = (connect "load") - -elementOnmousedown :: - (ElementClass self) => Signal self (EventM MouseEvent self ()) -elementOnmousedown = (connect "mousedown") - -#if WEBKIT_CHECK_VERSION(2,2,2) -elementOnmouseenter :: - (ElementClass self) => Signal self (EventM UIEvent self ()) -elementOnmouseenter = (connect "mouseenter") - -elementOnmouseleave :: - (ElementClass self) => Signal self (EventM UIEvent self ()) -elementOnmouseleave = (connect "mouseleave") -#endif - -elementOnmousemove :: - (ElementClass self) => Signal self (EventM MouseEvent self ()) -elementOnmousemove = (connect "mousemove") - -elementOnmouseout :: - (ElementClass self) => Signal self (EventM MouseEvent self ()) -elementOnmouseout = (connect "mouseout") - -elementOnmouseover :: - (ElementClass self) => Signal self (EventM MouseEvent self ()) -elementOnmouseover = (connect "mouseover") - -elementOnmouseup :: - (ElementClass self) => Signal self (EventM MouseEvent self ()) -elementOnmouseup = (connect "mouseup") - -elementOnmousewheel :: - (ElementClass self) => Signal self (EventM MouseEvent self ()) -elementOnmousewheel = (connect "mousewheel") - -elementOnscroll :: - (ElementClass self) => Signal self (EventM UIEvent self ()) -elementOnscroll = (connect "scroll") - -elementOnselect :: - (ElementClass self) => Signal self (EventM UIEvent self ()) -elementOnselect = (connect "select") - -elementOnsubmit :: - (ElementClass self) => Signal self (EventM UIEvent self ()) -elementOnsubmit = (connect "submit") - -elementOnbeforecut :: - (ElementClass self) => Signal self (EventM UIEvent self ()) -elementOnbeforecut = (connect "beforecut") - -elementOncut :: - (ElementClass self) => Signal self (EventM UIEvent self ()) -elementOncut = (connect "cut") - -elementOnbeforecopy :: - (ElementClass self) => Signal self (EventM UIEvent self ()) -elementOnbeforecopy = (connect "beforecopy") - -elementOncopy :: - (ElementClass self) => Signal self (EventM UIEvent self ()) -elementOncopy = (connect "copy") - -elementOnbeforepaste :: - (ElementClass self) => Signal self (EventM UIEvent self ()) -elementOnbeforepaste = (connect "beforepaste") - -elementOnpaste :: - (ElementClass self) => Signal self (EventM UIEvent self ()) -elementOnpaste = (connect "paste") - -elementOnreset :: - (ElementClass self) => Signal self (EventM UIEvent self ()) -elementOnreset = (connect "reset") - -elementOnsearch :: - (ElementClass self) => Signal self (EventM UIEvent self ()) -elementOnsearch = (connect "search") - -elementOnselectstart :: - (ElementClass self) => Signal self (EventM UIEvent self ()) -elementOnselectstart = (connect "selectstart") - -elementOntouchstart :: - (ElementClass self) => Signal self (EventM UIEvent self ()) -elementOntouchstart = (connect "touchstart") - -elementOntouchmove :: - (ElementClass self) => Signal self (EventM UIEvent self ()) -elementOntouchmove = (connect "touchmove") - -elementOntouchend :: - (ElementClass self) => Signal self (EventM UIEvent self ()) -elementOntouchend = (connect "touchend") - -elementOntouchcancel :: - (ElementClass self) => Signal self (EventM UIEvent self ()) -elementOntouchcancel = (connect "touchcancel") - -elementOnwebkitfullscreenchange :: - (ElementClass self) => Signal self (EventM UIEvent self ()) -elementOnwebkitfullscreenchange - = (connect "webkitfullscreenchange") - -elementOnwebkitfullscreenerror :: - (ElementClass self) => Signal self (EventM UIEvent self ()) -elementOnwebkitfullscreenerror = (connect "webkitfullscreenerror") +module Graphics.UI.Gtk.WebKit.DOM.Element( +getAttribute, +setAttribute, +removeAttribute, +getAttributeNode, +setAttributeNode, +removeAttributeNode, +getElementsByTagName, +#if WEBKIT_CHECK_VERSION(2,2,2) +hasAttributes, +#endif +getAttributeNS, +setAttributeNS, +removeAttributeNS, +getElementsByTagNameNS, +getAttributeNodeNS, +setAttributeNodeNS, +hasAttribute, +hasAttributeNS, +focus, +blur, +scrollIntoView, +scrollIntoViewIfNeeded, +scrollByLines, +scrollByPages, +getElementsByClassName, +querySelector, +querySelectorAll, +#if WEBKIT_CHECK_VERSION(99,0,0) +matches, +closest, +#endif +webkitMatchesSelector, +#if WEBKIT_CHECK_VERSION(2,2,2) +webkitRequestFullScreen, +webkitRequestFullscreen, +requestPointerLock, +#endif +#if WEBKIT_CHECK_VERSION(99,0,0) +webkitGetRegionFlowRanges, +#endif +pattern ALLOW_KEYBOARD_INPUT, +getTagName, +#if WEBKIT_CHECK_VERSION(2,2,2) +getAttributes, +#endif +getStyle, +#if WEBKIT_CHECK_VERSION(2,2,2) +setId, +getId, +#endif +getOffsetLeft, +getOffsetTop, +getOffsetWidth, +getOffsetHeight, +getClientLeft, +getClientTop, +getClientWidth, +getClientHeight, +setScrollLeft, +getScrollLeft, +setScrollTop, +getScrollTop, +getScrollWidth, +getScrollHeight, +getOffsetParent, +setInnerHTML, +getInnerHTML, +setOuterHTML, +getOuterHTML, +#if WEBKIT_CHECK_VERSION(2,2,2) +setClassName, +getClassName, +getClassList, +#endif +getFirstElementChild, +getLastElementChild, +getPreviousElementSibling, +getNextElementSibling, +getChildElementCount, +#if WEBKIT_CHECK_VERSION(2,2,2) +getWebkitRegionOverset, +#endif +abort, +blurEvent, +change, +click, +contextMenu, +dblClick, +drag, +dragEnd, +dragEnter, +dragLeave, +dragOver, +dragStart, +drop, +error, +focusEvent, +input, +invalid, +#if WEBKIT_CHECK_VERSION(2,2,2) +keyDown, +keyPress, +keyUp, +#endif +load, +mouseDown, +mouseEnter, +mouseLeave, +mouseMove, +mouseOut, +mouseOver, +mouseUp, +mouseWheel, +scroll, +select, +submit, +#if WEBKIT_CHECK_VERSION(2,4,0) +wheel, +#endif +beforeCut, +cut, +beforeCopy, +copy, +beforePaste, +paste, +reset, +search, +selectStart, +touchStart, +touchMove, +touchEnd, +touchCancel, +webKitFullscreenChange, +webKitFullscreenError, +webKitWillRevealBottom, +webKitWillRevealLeft, +webKitWillRevealRight, +webKitWillRevealTop, +Element, +castToElement, +gTypeElement, +ElementClass, +toElement, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures +import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + + +getAttribute :: + (MonadIO m, ElementClass self, GlibString string) => + self -> string -> m (Maybe string) +getAttribute self name + = liftIO + ((withUTFString name $ + \ namePtr -> + {# call webkit_dom_element_get_attribute #} (toElement self) + namePtr) + >>= + maybePeek readUTFString) + +setAttribute :: + (MonadIO m, ElementClass self, GlibString string) => + self -> string -> string -> m () +setAttribute self name value + = liftIO + (propagateGError $ + \ errorPtr_ -> + withUTFString value $ + \ valuePtr -> + withUTFString name $ + \ namePtr -> + {# call webkit_dom_element_set_attribute #} (toElement self) + namePtr + valuePtr + errorPtr_) + +removeAttribute :: + (MonadIO m, ElementClass self, GlibString string) => + self -> string -> m () +removeAttribute self name + = liftIO + (withUTFString name $ + \ namePtr -> + {# call webkit_dom_element_remove_attribute #} (toElement self) + namePtr) + +getAttributeNode :: + (MonadIO m, ElementClass self, GlibString string) => + self -> string -> m (Maybe Attr) +getAttributeNode self name + = liftIO + (maybeNull (makeNewGObject mkAttr) + (withUTFString name $ + \ namePtr -> + {# call webkit_dom_element_get_attribute_node #} (toElement self) + namePtr)) + +setAttributeNode :: + (MonadIO m, ElementClass self, AttrClass newAttr) => + self -> Maybe newAttr -> m (Maybe Attr) +setAttributeNode self newAttr + = liftIO + (maybeNull (makeNewGObject mkAttr) + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_element_set_attribute_node #} (toElement self) + (maybe (Attr nullForeignPtr) toAttr newAttr) + errorPtr_)) + +removeAttributeNode :: + (MonadIO m, ElementClass self, AttrClass oldAttr) => + self -> Maybe oldAttr -> m (Maybe Attr) +removeAttributeNode self oldAttr + = liftIO + (maybeNull (makeNewGObject mkAttr) + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_element_remove_attribute_node #} + (toElement self) + (maybe (Attr nullForeignPtr) toAttr oldAttr) + errorPtr_)) + +getElementsByTagName :: + (MonadIO m, ElementClass self, GlibString string) => + self -> string -> m (Maybe NodeList) +getElementsByTagName self name + = liftIO + (maybeNull (makeNewGObject mkNodeList) + (withUTFString name $ + \ namePtr -> + {# call webkit_dom_element_get_elements_by_tag_name #} + (toElement self) + namePtr)) + +#if WEBKIT_CHECK_VERSION(2,2,2) +hasAttributes :: (MonadIO m, ElementClass self) => self -> m Bool +hasAttributes self + = liftIO + (toBool <$> + ({# call webkit_dom_element_has_attributes #} (toElement self))) +#endif + +getAttributeNS :: + (MonadIO m, ElementClass self, GlibString string) => + self -> (Maybe string) -> string -> m string +getAttributeNS self namespaceURI localName + = liftIO + ((withUTFString localName $ + \ localNamePtr -> + maybeWith withUTFString namespaceURI $ + \ namespaceURIPtr -> + {# call webkit_dom_element_get_attribute_ns #} (toElement self) + namespaceURIPtr + localNamePtr) + >>= + readUTFString) + +setAttributeNS :: + (MonadIO m, ElementClass self, GlibString string) => + self -> (Maybe string) -> string -> string -> m () +setAttributeNS self namespaceURI qualifiedName value + = liftIO + (propagateGError $ + \ errorPtr_ -> + withUTFString value $ + \ valuePtr -> + withUTFString qualifiedName $ + \ qualifiedNamePtr -> + maybeWith withUTFString namespaceURI $ + \ namespaceURIPtr -> + {# call webkit_dom_element_set_attribute_ns #} (toElement self) + namespaceURIPtr + qualifiedNamePtr + valuePtr + errorPtr_) + +removeAttributeNS :: + (MonadIO m, ElementClass self, GlibString string) => + self -> (Maybe string) -> string -> m () +removeAttributeNS self namespaceURI localName + = liftIO + (withUTFString localName $ + \ localNamePtr -> + maybeWith withUTFString namespaceURI $ + \ namespaceURIPtr -> + {# call webkit_dom_element_remove_attribute_ns #} (toElement self) + namespaceURIPtr + localNamePtr) + +getElementsByTagNameNS :: + (MonadIO m, ElementClass self, GlibString string) => + self -> (Maybe string) -> string -> m (Maybe NodeList) +getElementsByTagNameNS self namespaceURI localName + = liftIO + (maybeNull (makeNewGObject mkNodeList) + (withUTFString localName $ + \ localNamePtr -> + maybeWith withUTFString namespaceURI $ + \ namespaceURIPtr -> + {# call webkit_dom_element_get_elements_by_tag_name_ns #} + (toElement self) + namespaceURIPtr + localNamePtr)) + +getAttributeNodeNS :: + (MonadIO m, ElementClass self, GlibString string) => + self -> (Maybe string) -> string -> m (Maybe Attr) +getAttributeNodeNS self namespaceURI localName + = liftIO + (maybeNull (makeNewGObject mkAttr) + (withUTFString localName $ + \ localNamePtr -> + maybeWith withUTFString namespaceURI $ + \ namespaceURIPtr -> + {# call webkit_dom_element_get_attribute_node_ns #} + (toElement self) + namespaceURIPtr + localNamePtr)) + +setAttributeNodeNS :: + (MonadIO m, ElementClass self, AttrClass newAttr) => + self -> Maybe newAttr -> m (Maybe Attr) +setAttributeNodeNS self newAttr + = liftIO + (maybeNull (makeNewGObject mkAttr) + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_element_set_attribute_node_ns #} + (toElement self) + (maybe (Attr nullForeignPtr) toAttr newAttr) + errorPtr_)) + +hasAttribute :: + (MonadIO m, ElementClass self, GlibString string) => + self -> string -> m Bool +hasAttribute self name + = liftIO + (toBool <$> + (withUTFString name $ + \ namePtr -> + {# call webkit_dom_element_has_attribute #} (toElement self) + namePtr)) + +hasAttributeNS :: + (MonadIO m, ElementClass self, GlibString string) => + self -> (Maybe string) -> string -> m Bool +hasAttributeNS self namespaceURI localName + = liftIO + (toBool <$> + (withUTFString localName $ + \ localNamePtr -> + maybeWith withUTFString namespaceURI $ + \ namespaceURIPtr -> + {# call webkit_dom_element_has_attribute_ns #} (toElement self) + namespaceURIPtr + localNamePtr)) + +focus :: (MonadIO m, ElementClass self) => self -> m () +focus self + = liftIO ({# call webkit_dom_element_focus #} (toElement self)) + +blur :: (MonadIO m, ElementClass self) => self -> m () +blur self + = liftIO ({# call webkit_dom_element_blur #} (toElement self)) + +scrollIntoView :: + (MonadIO m, ElementClass self) => self -> Bool -> m () +scrollIntoView self alignWithTop + = liftIO + ({# call webkit_dom_element_scroll_into_view #} (toElement self) + (fromBool alignWithTop)) + +scrollIntoViewIfNeeded :: + (MonadIO m, ElementClass self) => self -> Bool -> m () +scrollIntoViewIfNeeded self centerIfNeeded + = liftIO + ({# call webkit_dom_element_scroll_into_view_if_needed #} + (toElement self) + (fromBool centerIfNeeded)) + +scrollByLines :: + (MonadIO m, ElementClass self) => self -> Int -> m () +scrollByLines self lines + = liftIO + ({# call webkit_dom_element_scroll_by_lines #} (toElement self) + (fromIntegral lines)) + +scrollByPages :: + (MonadIO m, ElementClass self) => self -> Int -> m () +scrollByPages self pages + = liftIO + ({# call webkit_dom_element_scroll_by_pages #} (toElement self) + (fromIntegral pages)) + +getElementsByClassName :: + (MonadIO m, ElementClass self, GlibString string) => + self -> string -> m (Maybe NodeList) +getElementsByClassName self name + = liftIO + (maybeNull (makeNewGObject mkNodeList) + (withUTFString name $ + \ namePtr -> + {# call webkit_dom_element_get_elements_by_class_name #} + (toElement self) + namePtr)) + +querySelector :: + (MonadIO m, ElementClass self, GlibString string) => + self -> string -> m (Maybe Element) +querySelector self selectors + = liftIO + (maybeNull (makeNewGObject mkElement) + (propagateGError $ + \ errorPtr_ -> + withUTFString selectors $ + \ selectorsPtr -> + {# call webkit_dom_element_query_selector #} (toElement self) + selectorsPtr + errorPtr_)) + +querySelectorAll :: + (MonadIO m, ElementClass self, GlibString string) => + self -> string -> m (Maybe NodeList) +querySelectorAll self selectors + = liftIO + (maybeNull (makeNewGObject mkNodeList) + (propagateGError $ + \ errorPtr_ -> + withUTFString selectors $ + \ selectorsPtr -> + {# call webkit_dom_element_query_selector_all #} (toElement self) + selectorsPtr + errorPtr_)) + +#if WEBKIT_CHECK_VERSION(99,0,0) +matches :: + (MonadIO m, ElementClass self, GlibString string) => + self -> string -> m Bool +matches self selectors + = liftIO + (toBool <$> + (propagateGError $ + \ errorPtr_ -> + withUTFString selectors $ + \ selectorsPtr -> + {# call webkit_dom_element_matches #} (toElement self) selectorsPtr + errorPtr_)) + +closest :: + (MonadIO m, ElementClass self, GlibString string) => + self -> string -> m (Maybe Element) +closest self selectors + = liftIO + (maybeNull (makeNewGObject mkElement) + (propagateGError $ + \ errorPtr_ -> + withUTFString selectors $ + \ selectorsPtr -> + {# call webkit_dom_element_closest #} (toElement self) selectorsPtr + errorPtr_)) +#endif + +webkitMatchesSelector :: + (MonadIO m, ElementClass self, GlibString string) => + self -> string -> m Bool +webkitMatchesSelector self selectors + = liftIO + (toBool <$> + (propagateGError $ + \ errorPtr_ -> + withUTFString selectors $ + \ selectorsPtr -> + {# call webkit_dom_element_webkit_matches_selector #} + (toElement self) + selectorsPtr + errorPtr_)) + +#if WEBKIT_CHECK_VERSION(2,2,2) +webkitRequestFullScreen :: + (MonadIO m, ElementClass self) => self -> Word -> m () +webkitRequestFullScreen self flags + = liftIO + ({# call webkit_dom_element_webkit_request_full_screen #} + (toElement self) + (fromIntegral flags)) + +webkitRequestFullscreen :: + (MonadIO m, ElementClass self) => self -> m () +webkitRequestFullscreen self + = liftIO + ({# call webkit_dom_element_webkit_request_fullscreen #} + (toElement self)) + +requestPointerLock :: + (MonadIO m, ElementClass self) => self -> m () +requestPointerLock self + = liftIO +#if WEBKIT_CHECK_VERSION(2,6,0) + ({# call webkit_dom_element_request_pointer_lock #} +#else + ({# call webkit_dom_element_webkit_request_pointer_lock #} +#endif + (toElement self)) +#endif + +#if WEBKIT_CHECK_VERSION(99,0,0) +webkitGetRegionFlowRanges :: + (MonadIO m, ElementClass self) => self -> m [Maybe Range] +webkitGetRegionFlowRanges self + = liftIO + ({# call webkit_dom_element_webkit_get_region_flow_ranges #} + (toElement self)) +#endif +pattern ALLOW_KEYBOARD_INPUT = 1 + +getTagName :: + (MonadIO m, ElementClass self, GlibString string) => + self -> m (Maybe string) +getTagName self + = liftIO + (({# call webkit_dom_element_get_tag_name #} (toElement self)) >>= + maybePeek readUTFString) + +#if WEBKIT_CHECK_VERSION(2,2,2) +getAttributes :: + (MonadIO m, ElementClass self) => self -> m (Maybe NamedNodeMap) +getAttributes self + = liftIO + (maybeNull (makeNewGObject mkNamedNodeMap) + ({# call webkit_dom_element_get_attributes #} (toElement self))) +#endif + +getStyle :: + (MonadIO m, ElementClass self) => + self -> m (Maybe CSSStyleDeclaration) +getStyle self + = liftIO + (maybeNull (makeNewGObject mkCSSStyleDeclaration) + ({# call webkit_dom_element_get_style #} (toElement self))) + +#if WEBKIT_CHECK_VERSION(2,2,2) +setId :: + (MonadIO m, ElementClass self, GlibString string) => + self -> string -> m () +setId self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_element_set_id #} (toElement self) valPtr) + +getId :: + (MonadIO m, ElementClass self, GlibString string) => + self -> m string +getId self + = liftIO + (({# call webkit_dom_element_get_id #} (toElement self)) >>= + readUTFString) +#endif + +getOffsetLeft :: (MonadIO m, ElementClass self) => self -> m Double +getOffsetLeft self + = liftIO + (realToFrac <$> + ({# call webkit_dom_element_get_offset_left #} (toElement self))) + +getOffsetTop :: (MonadIO m, ElementClass self) => self -> m Double +getOffsetTop self + = liftIO + (realToFrac <$> + ({# call webkit_dom_element_get_offset_top #} (toElement self))) + +getOffsetWidth :: + (MonadIO m, ElementClass self) => self -> m Double +getOffsetWidth self + = liftIO + (realToFrac <$> + ({# call webkit_dom_element_get_offset_width #} (toElement self))) + +getOffsetHeight :: + (MonadIO m, ElementClass self) => self -> m Double +getOffsetHeight self + = liftIO + (realToFrac <$> + ({# call webkit_dom_element_get_offset_height #} (toElement self))) + +getClientLeft :: (MonadIO m, ElementClass self) => self -> m Double +getClientLeft self + = liftIO + (realToFrac <$> + ({# call webkit_dom_element_get_client_left #} (toElement self))) + +getClientTop :: (MonadIO m, ElementClass self) => self -> m Double +getClientTop self + = liftIO + (realToFrac <$> + ({# call webkit_dom_element_get_client_top #} (toElement self))) + +getClientWidth :: + (MonadIO m, ElementClass self) => self -> m Double +getClientWidth self + = liftIO + (realToFrac <$> + ({# call webkit_dom_element_get_client_width #} (toElement self))) + +getClientHeight :: + (MonadIO m, ElementClass self) => self -> m Double +getClientHeight self + = liftIO + (realToFrac <$> + ({# call webkit_dom_element_get_client_height #} (toElement self))) + +setScrollLeft :: + (MonadIO m, ElementClass self) => self -> Int -> m () +setScrollLeft self val + = liftIO + ({# call webkit_dom_element_set_scroll_left #} (toElement self) + (fromIntegral val)) + +getScrollLeft :: (MonadIO m, ElementClass self) => self -> m Int +getScrollLeft self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_element_get_scroll_left #} (toElement self))) + +setScrollTop :: + (MonadIO m, ElementClass self) => self -> Int -> m () +setScrollTop self val + = liftIO + ({# call webkit_dom_element_set_scroll_top #} (toElement self) + (fromIntegral val)) + +getScrollTop :: (MonadIO m, ElementClass self) => self -> m Int +getScrollTop self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_element_get_scroll_top #} (toElement self))) + +getScrollWidth :: (MonadIO m, ElementClass self) => self -> m Int +getScrollWidth self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_element_get_scroll_width #} (toElement self))) + +getScrollHeight :: (MonadIO m, ElementClass self) => self -> m Int +getScrollHeight self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_element_get_scroll_height #} (toElement self))) + +getOffsetParent :: + (MonadIO m, ElementClass self) => self -> m (Maybe Element) +getOffsetParent self + = liftIO + (maybeNull (makeNewGObject mkElement) + ({# call webkit_dom_element_get_offset_parent #} (toElement self))) + +setInnerHTML :: + (MonadIO m, ElementClass self, GlibString string) => + self -> (Maybe string) -> m () +setInnerHTML self val + = liftIO + (propagateGError $ + \ errorPtr_ -> + maybeWith withUTFString val $ + \ valPtr -> +#if WEBKIT_CHECK_VERSION(2,8,0) + {# call webkit_dom_element_set_inner_html #} (toElement self) +#else + ({# call webkit_dom_html_element_set_inner_html #} . castToHTMLElement) (toElement self) +#endif + valPtr + errorPtr_) + +getInnerHTML :: + (MonadIO m, ElementClass self, GlibString string) => + self -> m (Maybe string) +getInnerHTML self + = liftIO +#if WEBKIT_CHECK_VERSION(2,8,0) + (({# call webkit_dom_element_get_inner_html #} (toElement self)) +#else + ((({# call webkit_dom_html_element_get_inner_html #} . castToHTMLElement) (toElement self)) +#endif + >>= + maybePeek readUTFString) + +setOuterHTML :: + (MonadIO m, ElementClass self, GlibString string) => + self -> (Maybe string) -> m () +setOuterHTML self val + = liftIO + (propagateGError $ + \ errorPtr_ -> + maybeWith withUTFString val $ + \ valPtr -> +#if WEBKIT_CHECK_VERSION(2,8,0) + {# call webkit_dom_element_set_outer_html #} (toElement self) +#else + ({# call webkit_dom_html_element_set_outer_html #} . castToHTMLElement) (toElement self) +#endif + valPtr + errorPtr_) + +getOuterHTML :: + (MonadIO m, ElementClass self, GlibString string) => + self -> m (Maybe string) +getOuterHTML self + = liftIO +#if WEBKIT_CHECK_VERSION(2,8,0) + (({# call webkit_dom_element_get_outer_html #} (toElement self)) +#else + ((({# call webkit_dom_html_element_get_outer_html #} . castToHTMLElement) (toElement self)) +#endif + >>= + maybePeek readUTFString) + +#if WEBKIT_CHECK_VERSION(2,2,2) +setClassName :: + (MonadIO m, ElementClass self, GlibString string) => + self -> string -> m () +setClassName self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_element_set_class_name #} (toElement self) + valPtr) + +getClassName :: + (MonadIO m, ElementClass self, GlibString string) => + self -> m string +getClassName self + = liftIO + (({# call webkit_dom_element_get_class_name #} (toElement self)) + >>= + readUTFString) + +getClassList :: + (MonadIO m, ElementClass self) => self -> m (Maybe DOMTokenList) +getClassList self + = liftIO + (maybeNull (makeNewGObject mkDOMTokenList) + ({# call webkit_dom_element_get_class_list #} (toElement self))) +#endif + +getFirstElementChild :: + (MonadIO m, ElementClass self) => self -> m (Maybe Element) +getFirstElementChild self + = liftIO + (maybeNull (makeNewGObject mkElement) + ({# call webkit_dom_element_get_first_element_child #} + (toElement self))) + +getLastElementChild :: + (MonadIO m, ElementClass self) => self -> m (Maybe Element) +getLastElementChild self + = liftIO + (maybeNull (makeNewGObject mkElement) + ({# call webkit_dom_element_get_last_element_child #} + (toElement self))) + +getPreviousElementSibling :: + (MonadIO m, ElementClass self) => self -> m (Maybe Element) +getPreviousElementSibling self + = liftIO + (maybeNull (makeNewGObject mkElement) + ({# call webkit_dom_element_get_previous_element_sibling #} + (toElement self))) + +getNextElementSibling :: + (MonadIO m, ElementClass self) => self -> m (Maybe Element) +getNextElementSibling self + = liftIO + (maybeNull (makeNewGObject mkElement) + ({# call webkit_dom_element_get_next_element_sibling #} + (toElement self))) + +getChildElementCount :: + (MonadIO m, ElementClass self) => self -> m Word +getChildElementCount self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_element_get_child_element_count #} + (toElement self))) + +#if WEBKIT_CHECK_VERSION(2,2,2) +getWebkitRegionOverset :: + (MonadIO m, ElementClass self, GlibString string) => + self -> m string +getWebkitRegionOverset self + = liftIO + (({# call webkit_dom_element_get_webkit_region_overset #} + (toElement self)) + >>= + readUTFString) +#endif + +abort :: (ElementClass self) => EventName self UIEvent +abort = EventName "abort" + +blurEvent :: (ElementClass self) => EventName self UIEvent +blurEvent = EventName "blur" + +change :: (ElementClass self) => EventName self Event +change = EventName "change" + +click :: (ElementClass self) => EventName self MouseEvent +click = EventName "click" + +contextMenu :: (ElementClass self) => EventName self MouseEvent +contextMenu = EventName "contextmenu" + +dblClick :: (ElementClass self) => EventName self MouseEvent +dblClick = EventName "dblclick" + +drag :: (ElementClass self) => EventName self MouseEvent +drag = EventName "drag" + +dragEnd :: (ElementClass self) => EventName self MouseEvent +dragEnd = EventName "dragend" + +dragEnter :: (ElementClass self) => EventName self MouseEvent +dragEnter = EventName "dragenter" + +dragLeave :: (ElementClass self) => EventName self MouseEvent +dragLeave = EventName "dragleave" + +dragOver :: (ElementClass self) => EventName self MouseEvent +dragOver = EventName "dragover" + +dragStart :: (ElementClass self) => EventName self MouseEvent +dragStart = EventName "dragstart" + +drop :: (ElementClass self) => EventName self MouseEvent +drop = EventName "drop" + +error :: (ElementClass self) => EventName self UIEvent +error = EventName "error" + +focusEvent :: (ElementClass self) => EventName self UIEvent +focusEvent = EventName "focus" + +input :: (ElementClass self) => EventName self Event +input = EventName "input" + +invalid :: (ElementClass self) => EventName self Event +invalid = EventName "invalid" + +#if WEBKIT_CHECK_VERSION(2,2,2) +keyDown :: (ElementClass self) => EventName self KeyboardEvent +keyDown = EventName "keydown" + +keyPress :: (ElementClass self) => EventName self KeyboardEvent +keyPress = EventName "keypress" + +keyUp :: (ElementClass self) => EventName self KeyboardEvent +keyUp = EventName "keyup" +#endif + +load :: (ElementClass self) => EventName self UIEvent +load = EventName "load" + +mouseDown :: (ElementClass self) => EventName self MouseEvent +mouseDown = EventName "mousedown" + +mouseEnter :: (ElementClass self) => EventName self MouseEvent +mouseEnter = EventName "mouseenter" + +mouseLeave :: (ElementClass self) => EventName self MouseEvent +mouseLeave = EventName "mouseleave" + +mouseMove :: (ElementClass self) => EventName self MouseEvent +mouseMove = EventName "mousemove" + +mouseOut :: (ElementClass self) => EventName self MouseEvent +mouseOut = EventName "mouseout" + +mouseOver :: (ElementClass self) => EventName self MouseEvent +mouseOver = EventName "mouseover" + +mouseUp :: (ElementClass self) => EventName self MouseEvent +mouseUp = EventName "mouseup" + +mouseWheel :: (ElementClass self) => EventName self MouseEvent +mouseWheel = EventName "mousewheel" + +scroll :: (ElementClass self) => EventName self UIEvent +scroll = EventName "scroll" + +select :: (ElementClass self) => EventName self UIEvent +select = EventName "select" + +submit :: (ElementClass self) => EventName self Event +submit = EventName "submit" + +#if WEBKIT_CHECK_VERSION(2,4,0) +wheel :: (ElementClass self) => EventName self WheelEvent +wheel = EventName "wheel" +#endif + +beforeCut :: (ElementClass self) => EventName self Event +beforeCut = EventName "beforecut" + +cut :: (ElementClass self) => EventName self Event +cut = EventName "cut" + +beforeCopy :: (ElementClass self) => EventName self Event +beforeCopy = EventName "beforecopy" + +copy :: (ElementClass self) => EventName self Event +copy = EventName "copy" + +beforePaste :: (ElementClass self) => EventName self Event +beforePaste = EventName "beforepaste" + +paste :: (ElementClass self) => EventName self Event +paste = EventName "paste" + +reset :: (ElementClass self) => EventName self Event +reset = EventName "reset" + +search :: (ElementClass self) => EventName self Event +search = EventName "search" + +selectStart :: (ElementClass self) => EventName self Event +selectStart = EventName "selectstart" + +touchStart :: (ElementClass self) => EventName self UIEvent +touchStart = EventName "touchstart" + +touchMove :: (ElementClass self) => EventName self UIEvent +touchMove = EventName "touchmove" + +touchEnd :: (ElementClass self) => EventName self UIEvent +touchEnd = EventName "touchend" + +touchCancel :: (ElementClass self) => EventName self UIEvent +touchCancel = EventName "touchcancel" + +webKitFullscreenChange :: + (ElementClass self) => EventName self Event +webKitFullscreenChange = EventName "webkitfullscreenchange" + +webKitFullscreenError :: + (ElementClass self) => EventName self Event +webKitFullscreenError = EventName "webkitfullscreenerror" + +webKitWillRevealBottom :: + (ElementClass self) => EventName self Event +webKitWillRevealBottom = EventName "webkitwillrevealbottom" + +webKitWillRevealLeft :: (ElementClass self) => EventName self Event +webKitWillRevealLeft = EventName "webkitwillrevealleft" + +webKitWillRevealRight :: + (ElementClass self) => EventName self Event +webKitWillRevealRight = EventName "webkitwillrevealright" + +webKitWillRevealTop :: (ElementClass self) => EventName self Event +webKitWillRevealTop = EventName "webkitwillrevealtop" diff --git a/Graphics/UI/Gtk/WebKit/DOM/Enums.hs b/Graphics/UI/Gtk/WebKit/DOM/Enums.hs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/Enums.hs @@ -0,0 +1,312 @@ +module Graphics.UI.Gtk.WebKit.DOM.Enums( +DomEnum(..), +KeyType(..), +DomEnum, +KeyUsage(..), +CanvasWindingRule(..), +VideoPresentationMode(..), +TextTrackMode(..), +TextTrackKind(..), +DeviceType(..), +MediaUIPartID(..), +EndOfStreamError(..), +AppendMode(..), +SourceTypeEnum(..), +VideoFacingModeEnum(..), +MediaStreamTrackState(..), +RTCIceTransportsEnum(..), +RTCIdentityOptionEnum(..), +ReadableStreamStateType(..), +OverSampleType(..), +PageOverlayType(..), +XMLHttpRequestResponseType(..), +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures + + +class DomEnum e where + + enumToString :: e -> String + + stringToEnum :: String -> e + +data KeyType = KeyTypeSecret + | KeyTypePublic + | KeyTypePrivate + deriving (Show, Read, Eq, Ord, Typeable) + +instance DomEnum KeyType where + enumToString KeyTypeSecret = "secret" + enumToString KeyTypePublic = "public" + enumToString KeyTypePrivate = "private" + stringToEnum "secret" = KeyTypeSecret + stringToEnum "public" = KeyTypePublic + stringToEnum "private" = KeyTypePrivate + +data KeyUsage = KeyUsageEncrypt + | KeyUsageDecrypt + | KeyUsageSign + | KeyUsageVerify + | KeyUsageDeriveKey + | KeyUsageDeriveBits + | KeyUsageWrapKey + | KeyUsageUnwrapKey + deriving (Show, Read, Eq, Ord, Typeable) + +instance DomEnum KeyUsage where + enumToString KeyUsageEncrypt = "encrypt" + enumToString KeyUsageDecrypt = "decrypt" + enumToString KeyUsageSign = "sign" + enumToString KeyUsageVerify = "verify" + enumToString KeyUsageDeriveKey = "deriveKey" + enumToString KeyUsageDeriveBits = "deriveBits" + enumToString KeyUsageWrapKey = "wrapKey" + enumToString KeyUsageUnwrapKey = "unwrapKey" + stringToEnum "encrypt" = KeyUsageEncrypt + stringToEnum "decrypt" = KeyUsageDecrypt + stringToEnum "sign" = KeyUsageSign + stringToEnum "verify" = KeyUsageVerify + stringToEnum "deriveKey" = KeyUsageDeriveKey + stringToEnum "deriveBits" = KeyUsageDeriveBits + stringToEnum "wrapKey" = KeyUsageWrapKey + stringToEnum "unwrapKey" = KeyUsageUnwrapKey + +data CanvasWindingRule = CanvasWindingRuleNonzero + | CanvasWindingRuleEvenodd + deriving (Show, Read, Eq, Ord, Typeable) + +instance DomEnum CanvasWindingRule where + enumToString CanvasWindingRuleNonzero = "nonzero" + enumToString CanvasWindingRuleEvenodd = "evenodd" + stringToEnum "nonzero" = CanvasWindingRuleNonzero + stringToEnum "evenodd" = CanvasWindingRuleEvenodd + +data VideoPresentationMode = VideoPresentationModeFullscreen + | VideoPresentationModeOptimized + | VideoPresentationModeInline + deriving (Show, Read, Eq, Ord, Typeable) + +instance DomEnum VideoPresentationMode where + enumToString VideoPresentationModeFullscreen = "fullscreen" + enumToString VideoPresentationModeOptimized = "optimized" + enumToString VideoPresentationModeInline = "inline" + stringToEnum "fullscreen" = VideoPresentationModeFullscreen + stringToEnum "optimized" = VideoPresentationModeOptimized + stringToEnum "inline" = VideoPresentationModeInline + +data TextTrackMode = TextTrackModeDisabled + | TextTrackModeHidden + | TextTrackModeShowing + deriving (Show, Read, Eq, Ord, Typeable) + +instance DomEnum TextTrackMode where + enumToString TextTrackModeDisabled = "disabled" + enumToString TextTrackModeHidden = "hidden" + enumToString TextTrackModeShowing = "showing" + stringToEnum "disabled" = TextTrackModeDisabled + stringToEnum "hidden" = TextTrackModeHidden + stringToEnum "showing" = TextTrackModeShowing + +data TextTrackKind = TextTrackKindSubtitles + | TextTrackKindCaptions + | TextTrackKindDescriptions + | TextTrackKindChapters + | TextTrackKindMetadata + deriving (Show, Read, Eq, Ord, Typeable) + +instance DomEnum TextTrackKind where + enumToString TextTrackKindSubtitles = "subtitles" + enumToString TextTrackKindCaptions = "captions" + enumToString TextTrackKindDescriptions = "descriptions" + enumToString TextTrackKindChapters = "chapters" + enumToString TextTrackKindMetadata = "metadata" + stringToEnum "subtitles" = TextTrackKindSubtitles + stringToEnum "captions" = TextTrackKindCaptions + stringToEnum "descriptions" = TextTrackKindDescriptions + stringToEnum "chapters" = TextTrackKindChapters + stringToEnum "metadata" = TextTrackKindMetadata + +data DeviceType = DeviceTypeNone + | DeviceTypeAirplay + | DeviceTypeTvout + deriving (Show, Read, Eq, Ord, Typeable) + +instance DomEnum DeviceType where + enumToString DeviceTypeNone = "none" + enumToString DeviceTypeAirplay = "airplay" + enumToString DeviceTypeTvout = "tvout" + stringToEnum "none" = DeviceTypeNone + stringToEnum "airplay" = DeviceTypeAirplay + stringToEnum "tvout" = DeviceTypeTvout + +data MediaUIPartID = MediaUIPartIDOptimizedFullscreenButton + | MediaUIPartIDOptimizedFullscreenPlaceholder + deriving (Show, Read, Eq, Ord, Typeable) + +instance DomEnum MediaUIPartID where + enumToString MediaUIPartIDOptimizedFullscreenButton + = "optimized-fullscreen-button" + enumToString MediaUIPartIDOptimizedFullscreenPlaceholder + = "optimized-fullscreen-placeholder" + stringToEnum "optimized-fullscreen-button" + = MediaUIPartIDOptimizedFullscreenButton + stringToEnum "optimized-fullscreen-placeholder" + = MediaUIPartIDOptimizedFullscreenPlaceholder + +data EndOfStreamError = EndOfStreamErrorNetwork + | EndOfStreamErrorDecode + deriving (Show, Read, Eq, Ord, Typeable) + +instance DomEnum EndOfStreamError where + enumToString EndOfStreamErrorNetwork = "network" + enumToString EndOfStreamErrorDecode = "decode" + stringToEnum "network" = EndOfStreamErrorNetwork + stringToEnum "decode" = EndOfStreamErrorDecode + +data AppendMode = AppendModeSegments + | AppendModeSequence + deriving (Show, Read, Eq, Ord, Typeable) + +instance DomEnum AppendMode where + enumToString AppendModeSegments = "segments" + enumToString AppendModeSequence = "sequence" + stringToEnum "segments" = AppendModeSegments + stringToEnum "sequence" = AppendModeSequence + +data SourceTypeEnum = SourceTypeEnumNone + | SourceTypeEnumCamera + | SourceTypeEnumMicrophone + deriving (Show, Read, Eq, Ord, Typeable) + +instance DomEnum SourceTypeEnum where + enumToString SourceTypeEnumNone = "none" + enumToString SourceTypeEnumCamera = "camera" + enumToString SourceTypeEnumMicrophone = "microphone" + stringToEnum "none" = SourceTypeEnumNone + stringToEnum "camera" = SourceTypeEnumCamera + stringToEnum "microphone" = SourceTypeEnumMicrophone + +data VideoFacingModeEnum = VideoFacingModeEnumUser + | VideoFacingModeEnumEnvironment + | VideoFacingModeEnumLeft + | VideoFacingModeEnumRight + deriving (Show, Read, Eq, Ord, Typeable) + +instance DomEnum VideoFacingModeEnum where + enumToString VideoFacingModeEnumUser = "user" + enumToString VideoFacingModeEnumEnvironment = "environment" + enumToString VideoFacingModeEnumLeft = "left" + enumToString VideoFacingModeEnumRight = "right" + stringToEnum "user" = VideoFacingModeEnumUser + stringToEnum "environment" = VideoFacingModeEnumEnvironment + stringToEnum "left" = VideoFacingModeEnumLeft + stringToEnum "right" = VideoFacingModeEnumRight + +data MediaStreamTrackState = MediaStreamTrackStateNew + | MediaStreamTrackStateLive + | MediaStreamTrackStateEnded + deriving (Show, Read, Eq, Ord, Typeable) + +instance DomEnum MediaStreamTrackState where + enumToString MediaStreamTrackStateNew = "new" + enumToString MediaStreamTrackStateLive = "live" + enumToString MediaStreamTrackStateEnded = "ended" + stringToEnum "new" = MediaStreamTrackStateNew + stringToEnum "live" = MediaStreamTrackStateLive + stringToEnum "ended" = MediaStreamTrackStateEnded + +data RTCIceTransportsEnum = RTCIceTransportsEnumNone + | RTCIceTransportsEnumRelay + | RTCIceTransportsEnumAll + deriving (Show, Read, Eq, Ord, Typeable) + +instance DomEnum RTCIceTransportsEnum where + enumToString RTCIceTransportsEnumNone = "none" + enumToString RTCIceTransportsEnumRelay = "relay" + enumToString RTCIceTransportsEnumAll = "all" + stringToEnum "none" = RTCIceTransportsEnumNone + stringToEnum "relay" = RTCIceTransportsEnumRelay + stringToEnum "all" = RTCIceTransportsEnumAll + +data RTCIdentityOptionEnum = RTCIdentityOptionEnumYes + | RTCIdentityOptionEnumNo + | RTCIdentityOptionEnumIfconfigured + deriving (Show, Read, Eq, Ord, Typeable) + +instance DomEnum RTCIdentityOptionEnum where + enumToString RTCIdentityOptionEnumYes = "yes" + enumToString RTCIdentityOptionEnumNo = "no" + enumToString RTCIdentityOptionEnumIfconfigured = "ifconfigured" + stringToEnum "yes" = RTCIdentityOptionEnumYes + stringToEnum "no" = RTCIdentityOptionEnumNo + stringToEnum "ifconfigured" = RTCIdentityOptionEnumIfconfigured + +data ReadableStreamStateType = ReadableStreamStateTypeReadable + | ReadableStreamStateTypeWaiting + | ReadableStreamStateTypeClosed + | ReadableStreamStateTypeErrored + deriving (Show, Read, Eq, Ord, Typeable) + +instance DomEnum ReadableStreamStateType where + enumToString ReadableStreamStateTypeReadable = "readable" + enumToString ReadableStreamStateTypeWaiting = "waiting" + enumToString ReadableStreamStateTypeClosed = "closed" + enumToString ReadableStreamStateTypeErrored = "errored" + stringToEnum "readable" = ReadableStreamStateTypeReadable + stringToEnum "waiting" = ReadableStreamStateTypeWaiting + stringToEnum "closed" = ReadableStreamStateTypeClosed + stringToEnum "errored" = ReadableStreamStateTypeErrored + +data OverSampleType = OverSampleTypeNone + | OverSampleType2x + | OverSampleType4x + deriving (Show, Read, Eq, Ord, Typeable) + +instance DomEnum OverSampleType where + enumToString OverSampleTypeNone = "none" + enumToString OverSampleType2x = "2x" + enumToString OverSampleType4x = "4x" + stringToEnum "none" = OverSampleTypeNone + stringToEnum "2x" = OverSampleType2x + stringToEnum "4x" = OverSampleType4x + +data PageOverlayType = PageOverlayTypeView + | PageOverlayTypeDocument + deriving (Show, Read, Eq, Ord, Typeable) + +instance DomEnum PageOverlayType where + enumToString PageOverlayTypeView = "view" + enumToString PageOverlayTypeDocument = "document" + stringToEnum "view" = PageOverlayTypeView + stringToEnum "document" = PageOverlayTypeDocument + +data XMLHttpRequestResponseType = XMLHttpRequestResponseType + | XMLHttpRequestResponseTypeArraybuffer + | XMLHttpRequestResponseTypeBlob + | XMLHttpRequestResponseTypeDocument + | XMLHttpRequestResponseTypeJson + | XMLHttpRequestResponseTypeText + deriving (Show, Read, Eq, Ord, Typeable) + +instance DomEnum XMLHttpRequestResponseType where + enumToString XMLHttpRequestResponseType = "" + enumToString XMLHttpRequestResponseTypeArraybuffer = "arraybuffer" + enumToString XMLHttpRequestResponseTypeBlob = "blob" + enumToString XMLHttpRequestResponseTypeDocument = "document" + enumToString XMLHttpRequestResponseTypeJson = "json" + enumToString XMLHttpRequestResponseTypeText = "text" + stringToEnum "" = XMLHttpRequestResponseType + stringToEnum "arraybuffer" = XMLHttpRequestResponseTypeArraybuffer + stringToEnum "blob" = XMLHttpRequestResponseTypeBlob + stringToEnum "document" = XMLHttpRequestResponseTypeDocument + stringToEnum "json" = XMLHttpRequestResponseTypeJson + stringToEnum "text" = XMLHttpRequestResponseTypeText diff --git a/Graphics/UI/Gtk/WebKit/DOM/Event.chs b/Graphics/UI/Gtk/WebKit/DOM/Event.chs --- a/Graphics/UI/Gtk/WebKit/DOM/Event.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/Event.chs @@ -1,123 +1,183 @@ -module Graphics.UI.Gtk.WebKit.DOM.Event - (eventStopPropagation, eventPreventDefault, eventInitEvent, - eventStopImmediatePropagation, cNONE, cCAPTURING_PHASE, cAT_TARGET, - cBUBBLING_PHASE, cMOUSEDOWN, cMOUSEUP, cMOUSEOVER, cMOUSEOUT, - cMOUSEMOVE, cMOUSEDRAG, cCLICK, cDBLCLICK, cKEYDOWN, cKEYUP, - cKEYPRESS, cDRAGDROP, cFOCUS, cBLUR, cSELECT, cCHANGE, - eventGetTarget, eventGetCurrentTarget, eventGetEventPhase, - eventGetBubbles, eventGetCancelable, eventGetTimeStamp, - eventGetDefaultPrevented, eventGetSrcElement, eventSetReturnValue, - eventGetReturnValue, eventSetCancelBubble, eventGetCancelBubble, - Event, EventClass, castToEvent, gTypeEvent, toEvent) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.Event( +stopPropagation, +preventDefault, +initEvent, +stopImmediatePropagation, +pattern NONE, +pattern CAPTURING_PHASE, +pattern AT_TARGET, +pattern BUBBLING_PHASE, +pattern MOUSEDOWN, +pattern MOUSEUP, +pattern MOUSEOVER, +pattern MOUSEOUT, +pattern MOUSEMOVE, +pattern MOUSEDRAG, +pattern CLICK, +pattern DBLCLICK, +pattern KEYDOWN, +pattern KEYUP, +pattern KEYPRESS, +pattern DRAGDROP, +pattern FOCUS, +pattern BLUR, +pattern SELECT, +pattern CHANGE, +getTarget, +getCurrentTarget, +getEventPhase, +getBubbles, +getCancelable, +getTimeStamp, +getDefaultPrevented, +getSrcElement, +setReturnValue, +getReturnValue, +setCancelBubble, +getCancelBubble, +Event, +castToEvent, +gTypeEvent, +EventClass, +toEvent, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -eventStopPropagation :: (EventClass self) => self -> IO () -eventStopPropagation self - = {# call webkit_dom_event_stop_propagation #} (toEvent self) +stopPropagation :: (MonadIO m, EventClass self) => self -> m () +stopPropagation self + = liftIO + ({# call webkit_dom_event_stop_propagation #} (toEvent self)) -eventPreventDefault :: (EventClass self) => self -> IO () -eventPreventDefault self - = {# call webkit_dom_event_prevent_default #} (toEvent self) +preventDefault :: (MonadIO m, EventClass self) => self -> m () +preventDefault self + = liftIO + ({# call webkit_dom_event_prevent_default #} (toEvent self)) -eventInitEvent :: - (EventClass self) => self -> String -> Bool -> Bool -> IO () -eventInitEvent self eventTypeArg canBubbleArg cancelableArg - = withUTFString eventTypeArg $ - \ eventTypeArgPtr -> - {# call webkit_dom_event_init_event #} (toEvent self) - eventTypeArgPtr - (fromBool canBubbleArg) - (fromBool cancelableArg) +initEvent :: + (MonadIO m, EventClass self, GlibString string) => + self -> string -> Bool -> Bool -> m () +initEvent self eventTypeArg canBubbleArg cancelableArg + = liftIO + (withUTFString eventTypeArg $ + \ eventTypeArgPtr -> + {# call webkit_dom_event_init_event #} (toEvent self) + eventTypeArgPtr + (fromBool canBubbleArg) + (fromBool cancelableArg)) -eventStopImmediatePropagation :: (EventClass self) => self -> IO () -eventStopImmediatePropagation self - = {# call webkit_dom_event_stop_immediate_propagation #} - (toEvent self) -cNONE = 0 -cCAPTURING_PHASE = 1 -cAT_TARGET = 2 -cBUBBLING_PHASE = 3 -cMOUSEDOWN = 1 -cMOUSEUP = 2 -cMOUSEOVER = 4 -cMOUSEOUT = 8 -cMOUSEMOVE = 16 -cMOUSEDRAG = 32 -cCLICK = 64 -cDBLCLICK = 128 -cKEYDOWN = 256 -cKEYUP = 512 -cKEYPRESS = 1024 -cDRAGDROP = 2048 -cFOCUS = 4096 -cBLUR = 8192 -cSELECT = 16384 -cCHANGE = 32768 +stopImmediatePropagation :: + (MonadIO m, EventClass self) => self -> m () +stopImmediatePropagation self + = liftIO + ({# call webkit_dom_event_stop_immediate_propagation #} + (toEvent self)) +pattern NONE = 0 +pattern CAPTURING_PHASE = 1 +pattern AT_TARGET = 2 +pattern BUBBLING_PHASE = 3 +pattern MOUSEDOWN = 1 +pattern MOUSEUP = 2 +pattern MOUSEOVER = 4 +pattern MOUSEOUT = 8 +pattern MOUSEMOVE = 16 +pattern MOUSEDRAG = 32 +pattern CLICK = 64 +pattern DBLCLICK = 128 +pattern KEYDOWN = 256 +pattern KEYUP = 512 +pattern KEYPRESS = 1024 +pattern DRAGDROP = 2048 +pattern FOCUS = 4096 +pattern BLUR = 8192 +pattern SELECT = 16384 +pattern CHANGE = 32768 -eventGetTarget :: - (EventClass self) => self -> IO (Maybe EventTarget) -eventGetTarget self - = maybeNull (makeNewGObject mkEventTarget) - ({# call webkit_dom_event_get_target #} (toEvent self)) +getTarget :: + (MonadIO m, EventClass self) => self -> m (Maybe EventTarget) +getTarget self + = liftIO + (maybeNull (makeNewGObject mkEventTarget) + ({# call webkit_dom_event_get_target #} (toEvent self))) -eventGetCurrentTarget :: - (EventClass self) => self -> IO (Maybe EventTarget) -eventGetCurrentTarget self - = maybeNull (makeNewGObject mkEventTarget) - ({# call webkit_dom_event_get_current_target #} (toEvent self)) +getCurrentTarget :: + (MonadIO m, EventClass self) => self -> m (Maybe EventTarget) +getCurrentTarget self + = liftIO + (maybeNull (makeNewGObject mkEventTarget) + ({# call webkit_dom_event_get_current_target #} (toEvent self))) -eventGetEventPhase :: (EventClass self) => self -> IO Word -eventGetEventPhase self - = fromIntegral <$> - ({# call webkit_dom_event_get_event_phase #} (toEvent self)) +getEventPhase :: (MonadIO m, EventClass self) => self -> m Word +getEventPhase self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_event_get_event_phase #} (toEvent self))) -eventGetBubbles :: (EventClass self) => self -> IO Bool -eventGetBubbles self - = toBool <$> - ({# call webkit_dom_event_get_bubbles #} (toEvent self)) +getBubbles :: (MonadIO m, EventClass self) => self -> m Bool +getBubbles self + = liftIO + (toBool <$> + ({# call webkit_dom_event_get_bubbles #} (toEvent self))) -eventGetCancelable :: (EventClass self) => self -> IO Bool -eventGetCancelable self - = toBool <$> - ({# call webkit_dom_event_get_cancelable #} (toEvent self)) +getCancelable :: (MonadIO m, EventClass self) => self -> m Bool +getCancelable self + = liftIO + (toBool <$> + ({# call webkit_dom_event_get_cancelable #} (toEvent self))) -eventGetTimeStamp :: (EventClass self) => self -> IO Word -eventGetTimeStamp self - = fromIntegral <$> - ({# call webkit_dom_event_get_time_stamp #} (toEvent self)) +getTimeStamp :: (MonadIO m, EventClass self) => self -> m Word +getTimeStamp self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_event_get_time_stamp #} (toEvent self))) -eventGetDefaultPrevented :: (EventClass self) => self -> IO Bool -eventGetDefaultPrevented self - = toBool <$> - ({# call webkit_dom_event_get_default_prevented #} (toEvent self)) +getDefaultPrevented :: + (MonadIO m, EventClass self) => self -> m Bool +getDefaultPrevented self + = liftIO + (toBool <$> + ({# call webkit_dom_event_get_default_prevented #} (toEvent self))) -eventGetSrcElement :: - (EventClass self) => self -> IO (Maybe EventTarget) -eventGetSrcElement self - = maybeNull (makeNewGObject mkEventTarget) - ({# call webkit_dom_event_get_src_element #} (toEvent self)) +getSrcElement :: + (MonadIO m, EventClass self) => self -> m (Maybe EventTarget) +getSrcElement self + = liftIO + (maybeNull (makeNewGObject mkEventTarget) + ({# call webkit_dom_event_get_src_element #} (toEvent self))) -eventSetReturnValue :: (EventClass self) => self -> Bool -> IO () -eventSetReturnValue self val - = {# call webkit_dom_event_set_return_value #} (toEvent self) - (fromBool val) +setReturnValue :: + (MonadIO m, EventClass self) => self -> Bool -> m () +setReturnValue self val + = liftIO + ({# call webkit_dom_event_set_return_value #} (toEvent self) + (fromBool val)) -eventGetReturnValue :: (EventClass self) => self -> IO Bool -eventGetReturnValue self - = toBool <$> - ({# call webkit_dom_event_get_return_value #} (toEvent self)) +getReturnValue :: (MonadIO m, EventClass self) => self -> m Bool +getReturnValue self + = liftIO + (toBool <$> + ({# call webkit_dom_event_get_return_value #} (toEvent self))) -eventSetCancelBubble :: (EventClass self) => self -> Bool -> IO () -eventSetCancelBubble self val - = {# call webkit_dom_event_set_cancel_bubble #} (toEvent self) - (fromBool val) +setCancelBubble :: + (MonadIO m, EventClass self) => self -> Bool -> m () +setCancelBubble self val + = liftIO + ({# call webkit_dom_event_set_cancel_bubble #} (toEvent self) + (fromBool val)) -eventGetCancelBubble :: (EventClass self) => self -> IO Bool -eventGetCancelBubble self - = toBool <$> - ({# call webkit_dom_event_get_cancel_bubble #} (toEvent self)) +getCancelBubble :: (MonadIO m, EventClass self) => self -> m Bool +getCancelBubble self + = liftIO + (toBool <$> + ({# call webkit_dom_event_get_cancel_bubble #} (toEvent self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/EventM.hs b/Graphics/UI/Gtk/WebKit/DOM/EventM.hs --- a/Graphics/UI/Gtk/WebKit/DOM/EventM.hs +++ b/Graphics/UI/Gtk/WebKit/DOM/EventM.hs @@ -1,8 +1,11 @@ module Graphics.UI.Gtk.WebKit.DOM.EventM ( - Signal (..) -, EventM (..) -, target + EventM (..) +, EventName (..) +, newListener +, addListener +, removeListener +, on , event , eventTarget , eventCurrentTarget @@ -36,9 +39,9 @@ , mouseClientX , mouseClientY , mouseClientXY -, mouseWebkitMovementX -, mouseWebkitMovementY -, mouseWebkitMovementXY +, mouseMovementX +, mouseMovementY +, mouseMovementXY , mouseCtrlKey , mouseShiftKey , mouseAltKey @@ -53,212 +56,219 @@ , mouseXY , mouseFromElement , mouseToElement -, connect ) where -import Control.Applicative ((<$>)) -import Control.Monad.Reader ( ReaderT, ask, runReaderT ) -import Control.Monad.Trans ( liftIO ) -import Control.Monad ( void ) -import Graphics.UI.Gtk.WebKit.Types -import Graphics.UI.Gtk.WebKit.DOM.Event -import Graphics.UI.Gtk.WebKit.DOM.UIEvent -import Graphics.UI.Gtk.WebKit.DOM.MouseEvent -import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures -import Data.Word (Word) +import Control.Applicative ((<$>)) +import Control.Monad.Reader (ReaderT, ask, runReaderT) +import Control.Monad.Trans (MonadIO(..)) +import System.IO.Unsafe (unsafePerformIO) +import System.Glib.FFI (CString) +import System.Glib.UTFString (GlibString(..)) +import Graphics.UI.Gtk.WebKit.Types +import qualified Graphics.UI.Gtk.WebKit.DOM.Event as Event +import qualified Graphics.UI.Gtk.WebKit.DOM.UIEvent as UIEvent +import qualified Graphics.UI.Gtk.WebKit.DOM.MouseEvent as MouseEvent +import Graphics.UI.Gtk.WebKit.DOM.EventTarget +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures +import Data.Word (Word) -type Signal target callback = target -> callback -> IO (IO ()) +type EventM t e = ReaderT e IO -type EventM e t a = ReaderT (t, e) IO a +newListener :: (EventClass e) => EventM t e () -> IO (SaferEventListener t e) +newListener f = SaferEventListener <$> eventListenerNew (runReaderT f) -target :: EventM e t t -target = fst <$> ask +addListener :: (EventTargetClass t, EventClass e) => t -> EventName t e -> SaferEventListener t e -> Bool -> IO () +addListener target (EventName eventName) (SaferEventListener l) useCapture = + addEventListener target eventName (Just l) useCapture -event :: EventM e t e -event = snd <$> ask +removeListener :: (EventTargetClass t, EventClass e) => t -> EventName t e -> SaferEventListener t e -> Bool -> IO () +removeListener target (EventName eventName) (SaferEventListener l) useCapture = + removeEventListener target eventName (Just l) useCapture -eventTarget :: EventClass e => EventM e t (Maybe EventTarget) -eventTarget = event >>= (liftIO . eventGetTarget) +on :: (EventTargetClass t, EventClass e) => t -> EventName t e -> EventM t e () -> IO (IO ()) +on target eventName callback = do + l <- newListener callback + addListener target eventName l False + return (removeListener target eventName l False) -eventCurrentTarget :: EventClass e => EventM e t (Maybe EventTarget) -eventCurrentTarget = event >>= (liftIO . eventGetCurrentTarget) +target :: (EventClass e, GObjectClass t) => EventM t e (Maybe t) +target = (fmap (unsafeCastGObject . toGObject)) <$> (ask >>= Event.getTarget) -eventPhase :: EventClass e => EventM e t Word -eventPhase = event >>= (liftIO . eventGetEventPhase) +event :: EventM t e e +event = ask -bubbles :: EventClass e => EventM e t Bool -bubbles = event >>= (liftIO . eventGetBubbles) +eventTarget :: EventClass e => EventM t e (Maybe EventTarget) +eventTarget = event >>= Event.getTarget -cancelable :: EventClass e => EventM e t Bool -cancelable = event >>= (liftIO . eventGetCancelable) +eventCurrentTarget :: EventClass e => EventM t e (Maybe EventTarget) +eventCurrentTarget = event >>= Event.getCurrentTarget -timeStamp :: EventClass e => EventM e t Word -timeStamp = event >>= (liftIO . eventGetTimeStamp) +eventPhase :: EventClass e => EventM t e Word +eventPhase = event >>= Event.getEventPhase -stopPropagation :: EventClass e => EventM e t () -stopPropagation = event >>= (liftIO . eventStopPropagation) +bubbles :: EventClass e => EventM t e Bool +bubbles = event >>= Event.getBubbles -preventDefault :: EventClass e => EventM e t () -preventDefault = event >>= (liftIO . eventPreventDefault) +cancelable :: EventClass e => EventM t e Bool +cancelable = event >>= Event.getCancelable -defaultPrevented :: EventClass e => EventM e t Bool -defaultPrevented = event >>= (liftIO . eventGetDefaultPrevented) +timeStamp :: EventClass e => EventM t e Word +timeStamp = event >>= Event.getTimeStamp -stopImmediatePropagation :: EventClass e => EventM e t () -stopImmediatePropagation = event >>= (liftIO . eventStopImmediatePropagation) +stopPropagation :: EventClass e => EventM t e () +stopPropagation = event >>= Event.stopPropagation -srcElement :: EventClass e => EventM e t (Maybe EventTarget) -srcElement = event >>= (liftIO . eventGetSrcElement) +preventDefault :: EventClass e => EventM t e () +preventDefault = event >>= Event.preventDefault -getCancelBubble :: EventClass e => EventM e t Bool -getCancelBubble = event >>= (liftIO . eventGetCancelBubble) +defaultPrevented :: EventClass e => EventM t e Bool +defaultPrevented = event >>= Event.getDefaultPrevented -cancelBubble :: EventClass e => Bool -> EventM e t () -cancelBubble f = event >>= (liftIO . flip eventSetCancelBubble f) +stopImmediatePropagation :: EventClass e => EventM t e () +stopImmediatePropagation = event >>= Event.stopImmediatePropagation -getReturnValue :: EventClass e => EventM e t Bool -getReturnValue = event >>= (liftIO . eventGetReturnValue) +srcElement :: EventClass e => EventM t e (Maybe EventTarget) +srcElement = event >>= Event.getSrcElement -returnValue :: EventClass e => Bool -> EventM e t () -returnValue f = event >>= (liftIO . flip eventSetReturnValue f) +getCancelBubble :: EventClass e => EventM t e Bool +getCancelBubble = event >>= Event.getCancelBubble -uiView :: UIEventClass e => EventM e t (Maybe DOMWindow) -uiView = event >>= (liftIO . uiEventGetView) +cancelBubble :: EventClass e => Bool -> EventM t e () +cancelBubble f = event >>= flip Event.setCancelBubble f -uiDetail :: UIEventClass e => EventM e t Int -uiDetail = event >>= (liftIO . uiEventGetDetail) +getReturnValue :: EventClass e => EventM t e Bool +getReturnValue = event >>= Event.getReturnValue -uiKeyCode :: UIEventClass e => EventM e t Int -uiKeyCode = event >>= (liftIO . uiEventGetKeyCode) +returnValue :: EventClass e => Bool -> EventM t e () +returnValue f = event >>= flip Event.setReturnValue f -uiCharCode :: UIEventClass e => EventM e t Int -uiCharCode = event >>= (liftIO . uiEventGetCharCode) +uiView :: UIEventClass e => EventM t e (Maybe Window) +uiView = event >>= UIEvent.getView -uiLayerX :: UIEventClass e => EventM e t Int -uiLayerX = event >>= (liftIO . uiEventGetLayerX) +uiDetail :: UIEventClass e => EventM t e Int +uiDetail = event >>= UIEvent.getDetail -uiLayerY :: UIEventClass e => EventM e t Int -uiLayerY = event >>= (liftIO . uiEventGetLayerY) +uiKeyCode :: UIEventClass e => EventM t e Int +uiKeyCode = event >>= UIEvent.getKeyCode -uiLayerXY :: UIEventClass e => EventM e t (Int, Int) +uiCharCode :: UIEventClass e => EventM t e Int +uiCharCode = event >>= UIEvent.getCharCode + +uiLayerX :: UIEventClass e => EventM t e Int +uiLayerX = event >>= UIEvent.getLayerX + +uiLayerY :: UIEventClass e => EventM t e Int +uiLayerY = event >>= UIEvent.getLayerY + +uiLayerXY :: UIEventClass e => EventM t e (Int, Int) uiLayerXY = do - e <- event - liftIO $ do - x <- uiEventGetLayerX e - y <- uiEventGetLayerY e + e <- event + x <- UIEvent.getLayerX e + y <- UIEvent.getLayerY e return (x, y) -uiPageX :: UIEventClass e => EventM e t Int -uiPageX = event >>= (liftIO . uiEventGetPageX) +uiPageX :: UIEventClass e => EventM t e Int +uiPageX = event >>= UIEvent.getPageX -uiPageY :: UIEventClass e => EventM e t Int -uiPageY = event >>= (liftIO . uiEventGetPageY) +uiPageY :: UIEventClass e => EventM t e Int +uiPageY = event >>= UIEvent.getPageY -uiPageXY :: UIEventClass e => EventM e t (Int, Int) +uiPageXY :: UIEventClass e => EventM t e (Int, Int) uiPageXY = do - e <- event - liftIO $ do - x <- uiEventGetPageX e - y <- uiEventGetPageY e + e <- event + x <- UIEvent.getPageX e + y <- UIEvent.getPageY e return (x, y) -uiWhich :: UIEventClass e => EventM e t Int -uiWhich = event >>= (liftIO . uiEventGetWhich) +uiWhich :: UIEventClass e => EventM t e Int +uiWhich = event >>= UIEvent.getWhich -mouseScreenX :: MouseEventClass e => EventM e t Int -mouseScreenX = event >>= (liftIO . mouseEventGetScreenX) +mouseScreenX :: MouseEventClass e => EventM t e Int +mouseScreenX = event >>= MouseEvent.getScreenX -mouseScreenY :: MouseEventClass e => EventM e t Int -mouseScreenY = event >>= (liftIO . mouseEventGetScreenY) +mouseScreenY :: MouseEventClass e => EventM t e Int +mouseScreenY = event >>= MouseEvent.getScreenY -mouseScreenXY :: MouseEventClass e => EventM e t (Int, Int) +mouseScreenXY :: MouseEventClass e => EventM t e (Int, Int) mouseScreenXY = do - e <- event - liftIO $ do - x <- mouseEventGetScreenX e - y <- mouseEventGetScreenY e + e <- event + x <- MouseEvent.getScreenX e + y <- MouseEvent.getScreenY e return (x, y) -mouseClientX :: MouseEventClass e => EventM e t Int -mouseClientX = event >>= (liftIO . mouseEventGetClientX) +mouseClientX :: MouseEventClass e => EventM t e Int +mouseClientX = event >>= MouseEvent.getClientX -mouseClientY :: MouseEventClass e => EventM e t Int -mouseClientY = event >>= (liftIO . mouseEventGetClientY) +mouseClientY :: MouseEventClass e => EventM t e Int +mouseClientY = event >>= MouseEvent.getClientY -mouseClientXY :: MouseEventClass e => EventM e t (Int, Int) +mouseClientXY :: MouseEventClass e => EventM t e (Int, Int) mouseClientXY = do - e <- event - liftIO $ do - x <- mouseEventGetClientX e - y <- mouseEventGetClientY e + e <- event + x <- MouseEvent.getClientX e + y <- MouseEvent.getClientY e return (x, y) -mouseWebkitMovementX :: MouseEventClass e => EventM e t Int -mouseWebkitMovementX = event >>= (liftIO . mouseEventGetWebkitMovementX) +mouseMovementX :: MouseEventClass e => EventM t e Int +mouseMovementX = event >>= MouseEvent.getMovementX -mouseWebkitMovementY :: MouseEventClass e => EventM e t Int -mouseWebkitMovementY = event >>= (liftIO . mouseEventGetWebkitMovementY) +mouseMovementY :: MouseEventClass e => EventM t e Int +mouseMovementY = event >>= MouseEvent.getMovementY -mouseWebkitMovementXY :: MouseEventClass e => EventM e t (Int, Int) -mouseWebkitMovementXY = do - e <- event - liftIO $ do - x <- mouseEventGetWebkitMovementX e - y <- mouseEventGetWebkitMovementY e +mouseMovementXY :: MouseEventClass e => EventM t e (Int, Int) +mouseMovementXY = do + e <- event + x <- MouseEvent.getMovementX e + y <- MouseEvent.getMovementY e return (x, y) -mouseCtrlKey :: MouseEventClass e => EventM e t Bool -mouseCtrlKey = event >>= (liftIO . mouseEventGetCtrlKey) +mouseCtrlKey :: MouseEventClass e => EventM t e Bool +mouseCtrlKey = event >>= MouseEvent.getCtrlKey -mouseShiftKey :: MouseEventClass e => EventM e t Bool -mouseShiftKey = event >>= (liftIO . mouseEventGetShiftKey) +mouseShiftKey :: MouseEventClass e => EventM t e Bool +mouseShiftKey = event >>= MouseEvent.getShiftKey -mouseAltKey :: MouseEventClass e => EventM e t Bool -mouseAltKey = event >>= (liftIO . mouseEventGetAltKey) +mouseAltKey :: MouseEventClass e => EventM t e Bool +mouseAltKey = event >>= MouseEvent.getAltKey -mouseMetaKey :: MouseEventClass e => EventM e t Bool -mouseMetaKey = event >>= (liftIO . mouseEventGetMetaKey) +mouseMetaKey :: MouseEventClass e => EventM t e Bool +mouseMetaKey = event >>= MouseEvent.getMetaKey -mouseButton :: MouseEventClass e => EventM e t Word -mouseButton = event >>= (liftIO . mouseEventGetButton) +mouseButton :: MouseEventClass e => EventM t e Word +mouseButton = event >>= MouseEvent.getButton -mouseRelatedTarget :: MouseEventClass e => EventM e t (Maybe EventTarget) -mouseRelatedTarget = event >>= (liftIO . mouseEventGetRelatedTarget) +mouseRelatedTarget :: MouseEventClass e => EventM t e (Maybe EventTarget) +mouseRelatedTarget = event >>= MouseEvent.getRelatedTarget -mouseOffsetX :: MouseEventClass e => EventM e t Int -mouseOffsetX = event >>= (liftIO . mouseEventGetOffsetX) +mouseOffsetX :: MouseEventClass e => EventM t e Int +mouseOffsetX = event >>= MouseEvent.getOffsetX -mouseOffsetY :: MouseEventClass e => EventM e t Int -mouseOffsetY = event >>= (liftIO . mouseEventGetOffsetY) +mouseOffsetY :: MouseEventClass e => EventM t e Int +mouseOffsetY = event >>= MouseEvent.getOffsetY -mouseOffsetXY :: MouseEventClass e => EventM e t (Int, Int) +mouseOffsetXY :: MouseEventClass e => EventM t e (Int, Int) mouseOffsetXY = do - e <- event - liftIO $ do - x <- mouseEventGetOffsetX e - y <- mouseEventGetOffsetY e + e <- event + x <- MouseEvent.getOffsetX e + y <- MouseEvent.getOffsetY e return (x, y) -mouseX :: MouseEventClass e => EventM e t Int -mouseX = event >>= (liftIO . mouseEventGetX) +mouseX :: MouseEventClass e => EventM t e Int +mouseX = event >>= MouseEvent.getX -mouseY :: MouseEventClass e => EventM e t Int -mouseY = event >>= (liftIO . mouseEventGetY) +mouseY :: MouseEventClass e => EventM t e Int +mouseY = event >>= MouseEvent.getY -mouseXY :: MouseEventClass e => EventM e t (Int, Int) +mouseXY :: MouseEventClass e => EventM t e (Int, Int) mouseXY = do - e <- event - liftIO $ do - x <- mouseEventGetX e - y <- mouseEventGetY e + e <- event + x <- MouseEvent.getX e + y <- MouseEvent.getY e return (x, y) -mouseFromElement :: MouseEventClass e => EventM e t (Maybe Node) -mouseFromElement = event >>= (liftIO . mouseEventGetFromElement) +mouseFromElement :: MouseEventClass e => EventM t e (Maybe Node) +mouseFromElement = event >>= MouseEvent.getFromElement -mouseToElement :: MouseEventClass e => EventM e t (Maybe Node) -mouseToElement = event >>= (liftIO . mouseEventGetToElement) +mouseToElement :: MouseEventClass e => EventM t e (Maybe Node) +mouseToElement = event >>= MouseEvent.getToElement -connect :: (GObjectClass t, EventClass e) => String -> t -> EventM e t () -> IO (IO ()) -connect eventName target callback = do - eventTargetAddEventListener target eventName False $ curry (runReaderT callback) diff --git a/Graphics/UI/Gtk/WebKit/DOM/EventTarget.chs b/Graphics/UI/Gtk/WebKit/DOM/EventTarget.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/EventTarget.chs @@ -0,0 +1,75 @@ +module Graphics.UI.Gtk.WebKit.DOM.EventTarget( +addEventListener, +removeEventListener, +dispatchEvent, +EventTarget, +castToEventTarget, +gTypeEventTarget, +EventTargetClass, +toEventTarget, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + + +addEventListener :: + (MonadIO m, EventTargetClass self, EventListenerClass listener, + GlibString string) => + self -> string -> Maybe listener -> Bool -> m () +addEventListener self type' listener useCapture + = liftIO + (void $ + withUTFString type' $ + \ typePtr -> +#if !WEBKIT_CHECK_VERSION(2,4,0) + {# call webkit_dom_event_target_add_event_listener_closure #} +#else + {# call webkit_dom_event_target_add_event_listener_with_closure #} +#endif + (toEventTarget self) + typePtr + (maybe nullPtr (castPtr . unEventListener . toEventListener) + listener) + (fromBool useCapture)) + +removeEventListener :: + (MonadIO m, EventTargetClass self, EventListenerClass listener, + GlibString string) => + self -> string -> Maybe listener -> Bool -> m () +removeEventListener self type' listener useCapture + = liftIO + (void $ + withUTFString type' $ + \ typePtr -> +#if !WEBKIT_CHECK_VERSION(2,4,0) + {# call webkit_dom_event_target_remove_event_listener_closure #} +#else + {# call webkit_dom_event_target_remove_event_listener_with_closure #} +#endif + (toEventTarget self) + typePtr + (maybe nullPtr (castPtr . unEventListener . toEventListener) + listener) + (fromBool useCapture)) + +dispatchEvent :: + (MonadIO m, EventTargetClass self, EventClass event) => + self -> Maybe event -> m () +dispatchEvent self event + = liftIO . void $ + propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_event_target_dispatch_event #} + (toEventTarget self) + (maybe (Event nullForeignPtr) toEvent event) + errorPtr_ diff --git a/Graphics/UI/Gtk/WebKit/DOM/EventTargetClosures.chs b/Graphics/UI/Gtk/WebKit/DOM/EventTargetClosures.chs --- a/Graphics/UI/Gtk/WebKit/DOM/EventTargetClosures.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/EventTargetClosures.chs @@ -1,8 +1,10 @@ {-# LANGUAGE CPP #-} {-# CFILES events.c #-} module Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures - (eventTargetAddEventListener) where -import System.Glib.FFI (newStablePtr, StablePtr, Ptr(..), toBool, CInt(..), CChar, + (EventName(..), SaferEventListener(..), EventListener(..), unEventListener, EventListenerClass(..), + eventListenerNew, eventListenerNewAsync, eventListenerNewSync, eventListenerRelease) where +import Control.Monad.Reader (ReaderT) +import System.Glib.FFI (newStablePtr, freeStablePtr, StablePtr, Ptr(..), toBool, CInt(..), CChar, withForeignPtr, fromBool) import System.Glib.UTFString import Control.Applicative @@ -10,35 +12,45 @@ import System.Glib.GError import Control.Monad (void) +newtype EventName t e = EventName String +newtype SaferEventListener t e = SaferEventListener EventListener + {# pointer *GClosure newtype #} +data EventListener = EventListener (Ptr GClosure) (StablePtr (Ptr GObject -> Ptr GObject -> IO ())) + +unEventListener (EventListener p _) = p + +class EventListenerClass a where + toEventListener :: a -> EventListener + +instance EventListenerClass EventListener where + toEventListener a = a + foreign import ccall unsafe "gtk2hs_closure_new" gtk2hs_closure_new :: StablePtr a -> IO (Ptr GClosure) -eventTargetAddEventListener :: - (GObjectClass self, EventClass event) => - self -> String -> Bool -> (self -> event -> IO ()) -> IO (IO ()) -eventTargetAddEventListener self eventName bubble user = do +eventListenerNew :: EventClass event => (event -> IO ()) -> IO EventListener +eventListenerNew callback = do sptr <- newStablePtr action gclosurePtr <- gtk2hs_closure_new sptr - toBool <$> ( - withUTFString eventName $ \ eventNamePtr -> - {# call webkit_dom_event_target_add_event_listener_closure #} - (unsafeCastGObject $ toGObject self) - eventNamePtr - (GClosure gclosurePtr) - (fromBool bubble)) - return . void $ - withUTFString eventName $ \ eventNamePtr -> - {# call webkit_dom_event_target_remove_event_listener_closure #} - (unsafeCastGObject $ toGObject self) - eventNamePtr - (GClosure gclosurePtr) - (fromBool bubble) + return $ EventListener gclosurePtr sptr where action :: Ptr GObject -> Ptr GObject -> IO () action obj1 obj2 = failOnGError $ makeNewGObject (GObject, objectUnrefFromMainloop) (return obj2) >>= \obj2' -> makeNewGObject (GObject, objectUnrefFromMainloop) (return obj1) >>= \obj1' -> - user (unsafeCastGObject obj1') (unsafeCastGObject obj2') + callback (unsafeCastGObject obj2') + +eventListenerNewAsync :: EventClass event => (event -> IO ()) -> IO EventListener +eventListenerNewAsync = eventListenerNew + +eventListenerNewSync :: EventClass event => (event -> IO ()) -> IO EventListener +eventListenerNewSync = eventListenerNew + +foreign import ccall unsafe "g_closure_unref" + g_closure_unref :: Ptr GClosure -> IO () + +eventListenerRelease :: EventListener -> IO () +eventListenerRelease (EventListener gclosurePtr _) = g_closure_unref gclosurePtr diff --git a/Graphics/UI/Gtk/WebKit/DOM/Events.chs b/Graphics/UI/Gtk/WebKit/DOM/Events.chs deleted file mode 100644 --- a/Graphics/UI/Gtk/WebKit/DOM/Events.chs +++ /dev/null @@ -1,7 +0,0 @@ -module Graphics.UI.Gtk.WebKit.DOM.Events (Event, EventClass) where - -data Event = Event - -class EventClass a - -instance EventClass Event diff --git a/Graphics/UI/Gtk/WebKit/DOM/File.chs b/Graphics/UI/Gtk/WebKit/DOM/File.chs --- a/Graphics/UI/Gtk/WebKit/DOM/File.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/File.chs @@ -1,26 +1,41 @@ -module Graphics.UI.Gtk.WebKit.DOM.File - (fileGetName, -#if WEBKIT_CHECK_VERSION(2,2,2) - fileGetWebkitRelativePath, +module Graphics.UI.Gtk.WebKit.DOM.File( +getName, +#if WEBKIT_CHECK_VERSION(99,0,0) +getLastModifiedDate, #endif - File, FileClass, castToFile, gTypeFile, toFile) where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +File, +castToFile, +gTypeFile, +FileClass, +toFile, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM - -fileGetName :: (FileClass self) => self -> IO String -fileGetName self - = ({# call webkit_dom_file_get_name #} (toFile self)) >>= - readUTFString +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -#if WEBKIT_CHECK_VERSION(2,2,2) -fileGetWebkitRelativePath :: (FileClass self) => self -> IO String -fileGetWebkitRelativePath self - = ({# call webkit_dom_file_get_webkit_relative_path #} - (toFile self)) - >>= - readUTFString +getName :: + (MonadIO m, FileClass self, GlibString string) => self -> m string +getName self + = liftIO + (({# call webkit_dom_file_get_name #} (toFile self)) >>= + readUTFString) + +#if WEBKIT_CHECK_VERSION(99,0,0) +getLastModifiedDate :: + (MonadIO m, FileClass self) => self -> m (Maybe Date) +getLastModifiedDate self + = liftIO + (maybeNull (makeNewGObject mkDate) + ({# call webkit_dom_file_get_last_modified_date #} (toFile self))) #endif diff --git a/Graphics/UI/Gtk/WebKit/DOM/FileList.chs b/Graphics/UI/Gtk/WebKit/DOM/FileList.chs --- a/Graphics/UI/Gtk/WebKit/DOM/FileList.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/FileList.chs @@ -1,22 +1,37 @@ -module Graphics.UI.Gtk.WebKit.DOM.FileList - (fileListItem, fileListGetLength, FileList, FileListClass, - castToFileList, gTypeFileList, toFileList) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.FileList( +item, +getLength, +FileList, +castToFileList, +gTypeFileList, +FileListClass, +toFileList, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -fileListItem :: - (FileListClass self) => self -> Word -> IO (Maybe File) -fileListItem self index - = maybeNull (makeNewGObject mkFile) - ({# call webkit_dom_file_list_item #} (toFileList self) - (fromIntegral index)) +item :: + (MonadIO m, FileListClass self) => self -> Word -> m (Maybe File) +item self index + = liftIO + (maybeNull (makeNewGObject mkFile) + ({# call webkit_dom_file_list_item #} (toFileList self) + (fromIntegral index))) -fileListGetLength :: (FileListClass self) => self -> IO Word -fileListGetLength self - = fromIntegral <$> - ({# call webkit_dom_file_list_get_length #} (toFileList self)) +getLength :: (MonadIO m, FileListClass self) => self -> m Word +getLength self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_file_list_get_length #} (toFileList self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/Geolocation.chs b/Graphics/UI/Gtk/WebKit/DOM/Geolocation.chs --- a/Graphics/UI/Gtk/WebKit/DOM/Geolocation.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/Geolocation.chs @@ -1,17 +1,29 @@ -module Graphics.UI.Gtk.WebKit.DOM.Geolocation - (geolocationClearWatch, Geolocation, GeolocationClass, - castToGeolocation, gTypeGeolocation, toGeolocation) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.Geolocation( +clearWatch, +Geolocation, +castToGeolocation, +gTypeGeolocation, +GeolocationClass, +toGeolocation, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -geolocationClearWatch :: - (GeolocationClass self) => self -> Int -> IO () -geolocationClearWatch self watchID - = {# call webkit_dom_geolocation_clear_watch #} - (toGeolocation self) - (fromIntegral watchID) +clearWatch :: + (MonadIO m, GeolocationClass self) => self -> Int -> m () +clearWatch self watchID + = liftIO + ({# call webkit_dom_geolocation_clear_watch #} (toGeolocation self) + (fromIntegral watchID)) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLAnchorElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLAnchorElement.chs --- a/Graphics/UI/Gtk/WebKit/DOM/HTMLAnchorElement.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLAnchorElement.chs @@ -1,351 +1,490 @@ -module Graphics.UI.Gtk.WebKit.DOM.HTMLAnchorElement - (htmlAnchorElementSetCharset, htmlAnchorElementGetCharset, - htmlAnchorElementSetCoords, htmlAnchorElementGetCoords, - htmlAnchorElementSetDownload, htmlAnchorElementGetDownload, - htmlAnchorElementSetHref, htmlAnchorElementGetHref, - htmlAnchorElementSetHreflang, htmlAnchorElementGetHreflang, - htmlAnchorElementSetName, htmlAnchorElementGetName, - htmlAnchorElementSetPing, htmlAnchorElementGetPing, - htmlAnchorElementSetRel, htmlAnchorElementGetRel, - htmlAnchorElementSetRev, htmlAnchorElementGetRev, - htmlAnchorElementSetShape, htmlAnchorElementGetShape, - htmlAnchorElementSetTarget, htmlAnchorElementGetTarget, - htmlAnchorElementSetHash, htmlAnchorElementGetHash, - htmlAnchorElementSetHost, htmlAnchorElementGetHost, - htmlAnchorElementSetHostname, htmlAnchorElementGetHostname, - htmlAnchorElementSetPathname, htmlAnchorElementGetPathname, - htmlAnchorElementSetPort, htmlAnchorElementGetPort, - htmlAnchorElementSetProtocol, htmlAnchorElementGetProtocol, - htmlAnchorElementSetSearch, htmlAnchorElementGetSearch, - htmlAnchorElementGetOrigin, htmlAnchorElementGetText, - HTMLAnchorElement, HTMLAnchorElementClass, castToHTMLAnchorElement, - gTypeHTMLAnchorElement, toHTMLAnchorElement) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.HTMLAnchorElement( +setCharset, +getCharset, +setCoords, +getCoords, +setDownload, +getDownload, +setHref, +getHref, +setHreflang, +getHreflang, +setName, +getName, +setPing, +getPing, +setRel, +getRel, +setRev, +getRev, +setShape, +getShape, +setTarget, +getTarget, +setHash, +getHash, +setHost, +getHost, +setHostname, +getHostname, +setPathname, +getPathname, +setPort, +getPort, +setProtocol, +getProtocol, +setSearch, +getSearch, +getOrigin, +#if WEBKIT_CHECK_VERSION(99,0,0) +setText, +#endif +getText, +#if WEBKIT_CHECK_VERSION(99,0,0) +getRelList, +#endif +HTMLAnchorElement, +castToHTMLAnchorElement, +gTypeHTMLAnchorElement, +HTMLAnchorElementClass, +toHTMLAnchorElement, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -htmlAnchorElementSetCharset :: - (HTMLAnchorElementClass self) => self -> String -> IO () -htmlAnchorElementSetCharset self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_anchor_element_set_charset #} - (toHTMLAnchorElement self) - valPtr +setCharset :: + (MonadIO m, HTMLAnchorElementClass self, GlibString string) => + self -> string -> m () +setCharset self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_anchor_element_set_charset #} + (toHTMLAnchorElement self) + valPtr) -htmlAnchorElementGetCharset :: - (HTMLAnchorElementClass self) => self -> IO String -htmlAnchorElementGetCharset self - = ({# call webkit_dom_html_anchor_element_get_charset #} - (toHTMLAnchorElement self)) - >>= - readUTFString +getCharset :: + (MonadIO m, HTMLAnchorElementClass self, GlibString string) => + self -> m string +getCharset self + = liftIO + (({# call webkit_dom_html_anchor_element_get_charset #} + (toHTMLAnchorElement self)) + >>= + readUTFString) -htmlAnchorElementSetCoords :: - (HTMLAnchorElementClass self) => self -> String -> IO () -htmlAnchorElementSetCoords self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_anchor_element_set_coords #} - (toHTMLAnchorElement self) - valPtr +setCoords :: + (MonadIO m, HTMLAnchorElementClass self, GlibString string) => + self -> string -> m () +setCoords self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_anchor_element_set_coords #} + (toHTMLAnchorElement self) + valPtr) -htmlAnchorElementGetCoords :: - (HTMLAnchorElementClass self) => self -> IO String -htmlAnchorElementGetCoords self - = ({# call webkit_dom_html_anchor_element_get_coords #} - (toHTMLAnchorElement self)) - >>= - readUTFString +getCoords :: + (MonadIO m, HTMLAnchorElementClass self, GlibString string) => + self -> m string +getCoords self + = liftIO + (({# call webkit_dom_html_anchor_element_get_coords #} + (toHTMLAnchorElement self)) + >>= + readUTFString) -htmlAnchorElementSetDownload :: - (HTMLAnchorElementClass self) => self -> String -> IO () -htmlAnchorElementSetDownload self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_anchor_element_set_download #} - (toHTMLAnchorElement self) - valPtr +setDownload :: + (MonadIO m, HTMLAnchorElementClass self, GlibString string) => + self -> string -> m () +setDownload self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_anchor_element_set_download #} + (toHTMLAnchorElement self) + valPtr) -htmlAnchorElementGetDownload :: - (HTMLAnchorElementClass self) => self -> IO String -htmlAnchorElementGetDownload self - = ({# call webkit_dom_html_anchor_element_get_download #} - (toHTMLAnchorElement self)) - >>= - readUTFString +getDownload :: + (MonadIO m, HTMLAnchorElementClass self, GlibString string) => + self -> m string +getDownload self + = liftIO + (({# call webkit_dom_html_anchor_element_get_download #} + (toHTMLAnchorElement self)) + >>= + readUTFString) -htmlAnchorElementSetHref :: - (HTMLAnchorElementClass self) => self -> String -> IO () -htmlAnchorElementSetHref self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_anchor_element_set_href #} - (toHTMLAnchorElement self) - valPtr +setHref :: + (MonadIO m, HTMLAnchorElementClass self, GlibString string) => + self -> string -> m () +setHref self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_anchor_element_set_href #} + (toHTMLAnchorElement self) + valPtr) -htmlAnchorElementGetHref :: - (HTMLAnchorElementClass self) => self -> IO String -htmlAnchorElementGetHref self - = ({# call webkit_dom_html_anchor_element_get_href #} - (toHTMLAnchorElement self)) - >>= - readUTFString +getHref :: + (MonadIO m, HTMLAnchorElementClass self, GlibString string) => + self -> m string +getHref self + = liftIO + (({# call webkit_dom_html_anchor_element_get_href #} + (toHTMLAnchorElement self)) + >>= + readUTFString) -htmlAnchorElementSetHreflang :: - (HTMLAnchorElementClass self) => self -> String -> IO () -htmlAnchorElementSetHreflang self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_anchor_element_set_hreflang #} - (toHTMLAnchorElement self) - valPtr +setHreflang :: + (MonadIO m, HTMLAnchorElementClass self, GlibString string) => + self -> string -> m () +setHreflang self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_anchor_element_set_hreflang #} + (toHTMLAnchorElement self) + valPtr) -htmlAnchorElementGetHreflang :: - (HTMLAnchorElementClass self) => self -> IO String -htmlAnchorElementGetHreflang self - = ({# call webkit_dom_html_anchor_element_get_hreflang #} - (toHTMLAnchorElement self)) - >>= - readUTFString +getHreflang :: + (MonadIO m, HTMLAnchorElementClass self, GlibString string) => + self -> m string +getHreflang self + = liftIO + (({# call webkit_dom_html_anchor_element_get_hreflang #} + (toHTMLAnchorElement self)) + >>= + readUTFString) -htmlAnchorElementSetName :: - (HTMLAnchorElementClass self) => self -> String -> IO () -htmlAnchorElementSetName self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_anchor_element_set_name #} - (toHTMLAnchorElement self) - valPtr +setName :: + (MonadIO m, HTMLAnchorElementClass self, GlibString string) => + self -> string -> m () +setName self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_anchor_element_set_name #} + (toHTMLAnchorElement self) + valPtr) -htmlAnchorElementGetName :: - (HTMLAnchorElementClass self) => self -> IO String -htmlAnchorElementGetName self - = ({# call webkit_dom_html_anchor_element_get_name #} - (toHTMLAnchorElement self)) - >>= - readUTFString +getName :: + (MonadIO m, HTMLAnchorElementClass self, GlibString string) => + self -> m string +getName self + = liftIO + (({# call webkit_dom_html_anchor_element_get_name #} + (toHTMLAnchorElement self)) + >>= + readUTFString) -htmlAnchorElementSetPing :: - (HTMLAnchorElementClass self) => self -> String -> IO () -htmlAnchorElementSetPing self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_anchor_element_set_ping #} - (toHTMLAnchorElement self) - valPtr +setPing :: + (MonadIO m, HTMLAnchorElementClass self, GlibString string) => + self -> string -> m () +setPing self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_anchor_element_set_ping #} + (toHTMLAnchorElement self) + valPtr) -htmlAnchorElementGetPing :: - (HTMLAnchorElementClass self) => self -> IO String -htmlAnchorElementGetPing self - = ({# call webkit_dom_html_anchor_element_get_ping #} - (toHTMLAnchorElement self)) - >>= - readUTFString +getPing :: + (MonadIO m, HTMLAnchorElementClass self, GlibString string) => + self -> m string +getPing self + = liftIO + (({# call webkit_dom_html_anchor_element_get_ping #} + (toHTMLAnchorElement self)) + >>= + readUTFString) -htmlAnchorElementSetRel :: - (HTMLAnchorElementClass self) => self -> String -> IO () -htmlAnchorElementSetRel self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_anchor_element_set_rel #} - (toHTMLAnchorElement self) - valPtr +setRel :: + (MonadIO m, HTMLAnchorElementClass self, GlibString string) => + self -> string -> m () +setRel self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_anchor_element_set_rel #} + (toHTMLAnchorElement self) + valPtr) -htmlAnchorElementGetRel :: - (HTMLAnchorElementClass self) => self -> IO String -htmlAnchorElementGetRel self - = ({# call webkit_dom_html_anchor_element_get_rel #} - (toHTMLAnchorElement self)) - >>= - readUTFString +getRel :: + (MonadIO m, HTMLAnchorElementClass self, GlibString string) => + self -> m string +getRel self + = liftIO + (({# call webkit_dom_html_anchor_element_get_rel #} + (toHTMLAnchorElement self)) + >>= + readUTFString) -htmlAnchorElementSetRev :: - (HTMLAnchorElementClass self) => self -> String -> IO () -htmlAnchorElementSetRev self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_anchor_element_set_rev #} - (toHTMLAnchorElement self) - valPtr +setRev :: + (MonadIO m, HTMLAnchorElementClass self, GlibString string) => + self -> string -> m () +setRev self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_anchor_element_set_rev #} + (toHTMLAnchorElement self) + valPtr) -htmlAnchorElementGetRev :: - (HTMLAnchorElementClass self) => self -> IO String -htmlAnchorElementGetRev self - = ({# call webkit_dom_html_anchor_element_get_rev #} - (toHTMLAnchorElement self)) - >>= - readUTFString +getRev :: + (MonadIO m, HTMLAnchorElementClass self, GlibString string) => + self -> m string +getRev self + = liftIO + (({# call webkit_dom_html_anchor_element_get_rev #} + (toHTMLAnchorElement self)) + >>= + readUTFString) -htmlAnchorElementSetShape :: - (HTMLAnchorElementClass self) => self -> String -> IO () -htmlAnchorElementSetShape self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_anchor_element_set_shape #} - (toHTMLAnchorElement self) - valPtr +setShape :: + (MonadIO m, HTMLAnchorElementClass self, GlibString string) => + self -> string -> m () +setShape self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_anchor_element_set_shape #} + (toHTMLAnchorElement self) + valPtr) -htmlAnchorElementGetShape :: - (HTMLAnchorElementClass self) => self -> IO String -htmlAnchorElementGetShape self - = ({# call webkit_dom_html_anchor_element_get_shape #} - (toHTMLAnchorElement self)) - >>= - readUTFString +getShape :: + (MonadIO m, HTMLAnchorElementClass self, GlibString string) => + self -> m string +getShape self + = liftIO + (({# call webkit_dom_html_anchor_element_get_shape #} + (toHTMLAnchorElement self)) + >>= + readUTFString) -htmlAnchorElementSetTarget :: - (HTMLAnchorElementClass self) => self -> String -> IO () -htmlAnchorElementSetTarget self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_anchor_element_set_target #} - (toHTMLAnchorElement self) - valPtr +setTarget :: + (MonadIO m, HTMLAnchorElementClass self, GlibString string) => + self -> string -> m () +setTarget self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_anchor_element_set_target #} + (toHTMLAnchorElement self) + valPtr) -htmlAnchorElementGetTarget :: - (HTMLAnchorElementClass self) => self -> IO String -htmlAnchorElementGetTarget self - = ({# call webkit_dom_html_anchor_element_get_target #} - (toHTMLAnchorElement self)) - >>= - readUTFString +getTarget :: + (MonadIO m, HTMLAnchorElementClass self, GlibString string) => + self -> m string +getTarget self + = liftIO + (({# call webkit_dom_html_anchor_element_get_target #} + (toHTMLAnchorElement self)) + >>= + readUTFString) -htmlAnchorElementSetHash :: - (HTMLAnchorElementClass self) => self -> String -> IO () -htmlAnchorElementSetHash self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_anchor_element_set_hash #} - (toHTMLAnchorElement self) - valPtr +setHash :: + (MonadIO m, HTMLAnchorElementClass self, GlibString string) => + self -> (Maybe string) -> m () +setHash self val + = liftIO + (maybeWith withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_anchor_element_set_hash #} + (toHTMLAnchorElement self) + valPtr) -htmlAnchorElementGetHash :: - (HTMLAnchorElementClass self) => self -> IO String -htmlAnchorElementGetHash self - = ({# call webkit_dom_html_anchor_element_get_hash #} - (toHTMLAnchorElement self)) - >>= - readUTFString +getHash :: + (MonadIO m, HTMLAnchorElementClass self, GlibString string) => + self -> m (Maybe string) +getHash self + = liftIO + (({# call webkit_dom_html_anchor_element_get_hash #} + (toHTMLAnchorElement self)) + >>= + maybePeek readUTFString) -htmlAnchorElementSetHost :: - (HTMLAnchorElementClass self) => self -> String -> IO () -htmlAnchorElementSetHost self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_anchor_element_set_host #} - (toHTMLAnchorElement self) - valPtr +setHost :: + (MonadIO m, HTMLAnchorElementClass self, GlibString string) => + self -> (Maybe string) -> m () +setHost self val + = liftIO + (maybeWith withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_anchor_element_set_host #} + (toHTMLAnchorElement self) + valPtr) -htmlAnchorElementGetHost :: - (HTMLAnchorElementClass self) => self -> IO String -htmlAnchorElementGetHost self - = ({# call webkit_dom_html_anchor_element_get_host #} - (toHTMLAnchorElement self)) - >>= - readUTFString +getHost :: + (MonadIO m, HTMLAnchorElementClass self, GlibString string) => + self -> m (Maybe string) +getHost self + = liftIO + (({# call webkit_dom_html_anchor_element_get_host #} + (toHTMLAnchorElement self)) + >>= + maybePeek readUTFString) -htmlAnchorElementSetHostname :: - (HTMLAnchorElementClass self) => self -> String -> IO () -htmlAnchorElementSetHostname self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_anchor_element_set_hostname #} - (toHTMLAnchorElement self) - valPtr +setHostname :: + (MonadIO m, HTMLAnchorElementClass self, GlibString string) => + self -> (Maybe string) -> m () +setHostname self val + = liftIO + (maybeWith withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_anchor_element_set_hostname #} + (toHTMLAnchorElement self) + valPtr) -htmlAnchorElementGetHostname :: - (HTMLAnchorElementClass self) => self -> IO String -htmlAnchorElementGetHostname self - = ({# call webkit_dom_html_anchor_element_get_hostname #} - (toHTMLAnchorElement self)) - >>= - readUTFString +getHostname :: + (MonadIO m, HTMLAnchorElementClass self, GlibString string) => + self -> m (Maybe string) +getHostname self + = liftIO + (({# call webkit_dom_html_anchor_element_get_hostname #} + (toHTMLAnchorElement self)) + >>= + maybePeek readUTFString) -htmlAnchorElementSetPathname :: - (HTMLAnchorElementClass self) => self -> String -> IO () -htmlAnchorElementSetPathname self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_anchor_element_set_pathname #} - (toHTMLAnchorElement self) - valPtr +setPathname :: + (MonadIO m, HTMLAnchorElementClass self, GlibString string) => + self -> (Maybe string) -> m () +setPathname self val + = liftIO + (maybeWith withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_anchor_element_set_pathname #} + (toHTMLAnchorElement self) + valPtr) -htmlAnchorElementGetPathname :: - (HTMLAnchorElementClass self) => self -> IO String -htmlAnchorElementGetPathname self - = ({# call webkit_dom_html_anchor_element_get_pathname #} - (toHTMLAnchorElement self)) - >>= - readUTFString +getPathname :: + (MonadIO m, HTMLAnchorElementClass self, GlibString string) => + self -> m (Maybe string) +getPathname self + = liftIO + (({# call webkit_dom_html_anchor_element_get_pathname #} + (toHTMLAnchorElement self)) + >>= + maybePeek readUTFString) -htmlAnchorElementSetPort :: - (HTMLAnchorElementClass self) => self -> String -> IO () -htmlAnchorElementSetPort self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_anchor_element_set_port #} - (toHTMLAnchorElement self) - valPtr +setPort :: + (MonadIO m, HTMLAnchorElementClass self, GlibString string) => + self -> (Maybe string) -> m () +setPort self val + = liftIO + (maybeWith withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_anchor_element_set_port #} + (toHTMLAnchorElement self) + valPtr) -htmlAnchorElementGetPort :: - (HTMLAnchorElementClass self) => self -> IO String -htmlAnchorElementGetPort self - = ({# call webkit_dom_html_anchor_element_get_port #} - (toHTMLAnchorElement self)) - >>= - readUTFString +getPort :: + (MonadIO m, HTMLAnchorElementClass self, GlibString string) => + self -> m (Maybe string) +getPort self + = liftIO + (({# call webkit_dom_html_anchor_element_get_port #} + (toHTMLAnchorElement self)) + >>= + maybePeek readUTFString) -htmlAnchorElementSetProtocol :: - (HTMLAnchorElementClass self) => self -> String -> IO () -htmlAnchorElementSetProtocol self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_anchor_element_set_protocol #} - (toHTMLAnchorElement self) - valPtr +setProtocol :: + (MonadIO m, HTMLAnchorElementClass self, GlibString string) => + self -> (Maybe string) -> m () +setProtocol self val + = liftIO + (maybeWith withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_anchor_element_set_protocol #} + (toHTMLAnchorElement self) + valPtr) -htmlAnchorElementGetProtocol :: - (HTMLAnchorElementClass self) => self -> IO String -htmlAnchorElementGetProtocol self - = ({# call webkit_dom_html_anchor_element_get_protocol #} - (toHTMLAnchorElement self)) - >>= - readUTFString +getProtocol :: + (MonadIO m, HTMLAnchorElementClass self, GlibString string) => + self -> m (Maybe string) +getProtocol self + = liftIO + (({# call webkit_dom_html_anchor_element_get_protocol #} + (toHTMLAnchorElement self)) + >>= + maybePeek readUTFString) -htmlAnchorElementSetSearch :: - (HTMLAnchorElementClass self) => self -> String -> IO () -htmlAnchorElementSetSearch self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_anchor_element_set_search #} - (toHTMLAnchorElement self) - valPtr +setSearch :: + (MonadIO m, HTMLAnchorElementClass self, GlibString string) => + self -> (Maybe string) -> m () +setSearch self val + = liftIO + (maybeWith withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_anchor_element_set_search #} + (toHTMLAnchorElement self) + valPtr) -htmlAnchorElementGetSearch :: - (HTMLAnchorElementClass self) => self -> IO String -htmlAnchorElementGetSearch self - = ({# call webkit_dom_html_anchor_element_get_search #} - (toHTMLAnchorElement self)) - >>= - readUTFString +getSearch :: + (MonadIO m, HTMLAnchorElementClass self, GlibString string) => + self -> m (Maybe string) +getSearch self + = liftIO + (({# call webkit_dom_html_anchor_element_get_search #} + (toHTMLAnchorElement self)) + >>= + maybePeek readUTFString) -htmlAnchorElementGetOrigin :: - (HTMLAnchorElementClass self) => self -> IO String -htmlAnchorElementGetOrigin self - = ({# call webkit_dom_html_anchor_element_get_origin #} - (toHTMLAnchorElement self)) - >>= - readUTFString +getOrigin :: + (MonadIO m, HTMLAnchorElementClass self, GlibString string) => + self -> m (Maybe string) +getOrigin self + = liftIO + (({# call webkit_dom_html_anchor_element_get_origin #} + (toHTMLAnchorElement self)) + >>= + maybePeek readUTFString) + +#if WEBKIT_CHECK_VERSION(99,0,0) +setText :: + (MonadIO m, HTMLAnchorElementClass self, GlibString string) => + self -> string -> m () +setText self val + = liftIO + (propagateGError $ + \ errorPtr_ -> + withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_anchor_element_set_text #} + (toHTMLAnchorElement self) + valPtr + errorPtr_) +#endif -htmlAnchorElementGetText :: - (HTMLAnchorElementClass self) => self -> IO String -htmlAnchorElementGetText self - = ({# call webkit_dom_html_anchor_element_get_text #} - (toHTMLAnchorElement self)) - >>= - readUTFString +getText :: + (MonadIO m, HTMLAnchorElementClass self, GlibString string) => + self -> m string +getText self + = liftIO + (({# call webkit_dom_html_anchor_element_get_text #} + (toHTMLAnchorElement self)) + >>= + readUTFString) + +#if WEBKIT_CHECK_VERSION(99,0,0) +getRelList :: + (MonadIO m, HTMLAnchorElementClass self) => + self -> m (Maybe DOMTokenList) +getRelList self + = liftIO + (maybeNull (makeNewGObject mkDOMTokenList) + ({# call webkit_dom_html_anchor_element_get_rel_list #} + (toHTMLAnchorElement self))) +#endif diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLAppletElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLAppletElement.chs --- a/Graphics/UI/Gtk/WebKit/DOM/HTMLAppletElement.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLAppletElement.chs @@ -1,202 +1,264 @@ -module Graphics.UI.Gtk.WebKit.DOM.HTMLAppletElement - (htmlAppletElementSetAlign, htmlAppletElementGetAlign, - htmlAppletElementSetAlt, htmlAppletElementGetAlt, - htmlAppletElementSetArchive, htmlAppletElementGetArchive, - htmlAppletElementSetCode, htmlAppletElementGetCode, - htmlAppletElementSetCodeBase, htmlAppletElementGetCodeBase, - htmlAppletElementSetHeight, htmlAppletElementGetHeight, - htmlAppletElementSetHspace, htmlAppletElementGetHspace, - htmlAppletElementSetName, htmlAppletElementGetName, - htmlAppletElementSetObject, htmlAppletElementGetObject, - htmlAppletElementSetVspace, htmlAppletElementGetVspace, - htmlAppletElementSetWidth, htmlAppletElementGetWidth, - HTMLAppletElement, HTMLAppletElementClass, castToHTMLAppletElement, - gTypeHTMLAppletElement, toHTMLAppletElement) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.HTMLAppletElement( +setAlign, +getAlign, +setAlt, +getAlt, +setArchive, +getArchive, +setCode, +getCode, +setCodeBase, +getCodeBase, +setHeight, +getHeight, +setHspace, +getHspace, +setName, +getName, +setObject, +getObject, +setVspace, +getVspace, +setWidth, +getWidth, +HTMLAppletElement, +castToHTMLAppletElement, +gTypeHTMLAppletElement, +HTMLAppletElementClass, +toHTMLAppletElement, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -htmlAppletElementSetAlign :: - (HTMLAppletElementClass self) => self -> String -> IO () -htmlAppletElementSetAlign self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_applet_element_set_align #} - (toHTMLAppletElement self) - valPtr +setAlign :: + (MonadIO m, HTMLAppletElementClass self, GlibString string) => + self -> string -> m () +setAlign self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_applet_element_set_align #} + (toHTMLAppletElement self) + valPtr) -htmlAppletElementGetAlign :: - (HTMLAppletElementClass self) => self -> IO String -htmlAppletElementGetAlign self - = ({# call webkit_dom_html_applet_element_get_align #} - (toHTMLAppletElement self)) - >>= - readUTFString +getAlign :: + (MonadIO m, HTMLAppletElementClass self, GlibString string) => + self -> m string +getAlign self + = liftIO + (({# call webkit_dom_html_applet_element_get_align #} + (toHTMLAppletElement self)) + >>= + readUTFString) -htmlAppletElementSetAlt :: - (HTMLAppletElementClass self) => self -> String -> IO () -htmlAppletElementSetAlt self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_applet_element_set_alt #} - (toHTMLAppletElement self) - valPtr +setAlt :: + (MonadIO m, HTMLAppletElementClass self, GlibString string) => + self -> string -> m () +setAlt self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_applet_element_set_alt #} + (toHTMLAppletElement self) + valPtr) -htmlAppletElementGetAlt :: - (HTMLAppletElementClass self) => self -> IO String -htmlAppletElementGetAlt self - = ({# call webkit_dom_html_applet_element_get_alt #} - (toHTMLAppletElement self)) - >>= - readUTFString +getAlt :: + (MonadIO m, HTMLAppletElementClass self, GlibString string) => + self -> m string +getAlt self + = liftIO + (({# call webkit_dom_html_applet_element_get_alt #} + (toHTMLAppletElement self)) + >>= + readUTFString) -htmlAppletElementSetArchive :: - (HTMLAppletElementClass self) => self -> String -> IO () -htmlAppletElementSetArchive self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_applet_element_set_archive #} - (toHTMLAppletElement self) - valPtr +setArchive :: + (MonadIO m, HTMLAppletElementClass self, GlibString string) => + self -> string -> m () +setArchive self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_applet_element_set_archive #} + (toHTMLAppletElement self) + valPtr) -htmlAppletElementGetArchive :: - (HTMLAppletElementClass self) => self -> IO String -htmlAppletElementGetArchive self - = ({# call webkit_dom_html_applet_element_get_archive #} - (toHTMLAppletElement self)) - >>= - readUTFString +getArchive :: + (MonadIO m, HTMLAppletElementClass self, GlibString string) => + self -> m string +getArchive self + = liftIO + (({# call webkit_dom_html_applet_element_get_archive #} + (toHTMLAppletElement self)) + >>= + readUTFString) -htmlAppletElementSetCode :: - (HTMLAppletElementClass self) => self -> String -> IO () -htmlAppletElementSetCode self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_applet_element_set_code #} - (toHTMLAppletElement self) - valPtr +setCode :: + (MonadIO m, HTMLAppletElementClass self, GlibString string) => + self -> string -> m () +setCode self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_applet_element_set_code #} + (toHTMLAppletElement self) + valPtr) -htmlAppletElementGetCode :: - (HTMLAppletElementClass self) => self -> IO String -htmlAppletElementGetCode self - = ({# call webkit_dom_html_applet_element_get_code #} - (toHTMLAppletElement self)) - >>= - readUTFString +getCode :: + (MonadIO m, HTMLAppletElementClass self, GlibString string) => + self -> m string +getCode self + = liftIO + (({# call webkit_dom_html_applet_element_get_code #} + (toHTMLAppletElement self)) + >>= + readUTFString) -htmlAppletElementSetCodeBase :: - (HTMLAppletElementClass self) => self -> String -> IO () -htmlAppletElementSetCodeBase self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_applet_element_set_code_base #} - (toHTMLAppletElement self) - valPtr +setCodeBase :: + (MonadIO m, HTMLAppletElementClass self, GlibString string) => + self -> string -> m () +setCodeBase self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_applet_element_set_code_base #} + (toHTMLAppletElement self) + valPtr) -htmlAppletElementGetCodeBase :: - (HTMLAppletElementClass self) => self -> IO String -htmlAppletElementGetCodeBase self - = ({# call webkit_dom_html_applet_element_get_code_base #} - (toHTMLAppletElement self)) - >>= - readUTFString +getCodeBase :: + (MonadIO m, HTMLAppletElementClass self, GlibString string) => + self -> m string +getCodeBase self + = liftIO + (({# call webkit_dom_html_applet_element_get_code_base #} + (toHTMLAppletElement self)) + >>= + readUTFString) -htmlAppletElementSetHeight :: - (HTMLAppletElementClass self) => self -> String -> IO () -htmlAppletElementSetHeight self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_applet_element_set_height #} - (toHTMLAppletElement self) - valPtr +setHeight :: + (MonadIO m, HTMLAppletElementClass self, GlibString string) => + self -> string -> m () +setHeight self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_applet_element_set_height #} + (toHTMLAppletElement self) + valPtr) -htmlAppletElementGetHeight :: - (HTMLAppletElementClass self) => self -> IO String -htmlAppletElementGetHeight self - = ({# call webkit_dom_html_applet_element_get_height #} - (toHTMLAppletElement self)) - >>= - readUTFString +getHeight :: + (MonadIO m, HTMLAppletElementClass self, GlibString string) => + self -> m string +getHeight self + = liftIO + (({# call webkit_dom_html_applet_element_get_height #} + (toHTMLAppletElement self)) + >>= + readUTFString) -htmlAppletElementSetHspace :: - (HTMLAppletElementClass self) => self -> Int -> IO () -htmlAppletElementSetHspace self val - = {# call webkit_dom_html_applet_element_set_hspace #} - (toHTMLAppletElement self) - (fromIntegral val) +setHspace :: + (MonadIO m, HTMLAppletElementClass self) => self -> Int -> m () +setHspace self val + = liftIO + ({# call webkit_dom_html_applet_element_set_hspace #} + (toHTMLAppletElement self) + (fromIntegral val)) -htmlAppletElementGetHspace :: - (HTMLAppletElementClass self) => self -> IO Int -htmlAppletElementGetHspace self - = fromIntegral <$> - ({# call webkit_dom_html_applet_element_get_hspace #} - (toHTMLAppletElement self)) +getHspace :: + (MonadIO m, HTMLAppletElementClass self) => self -> m Int +getHspace self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_applet_element_get_hspace #} + (toHTMLAppletElement self))) -htmlAppletElementSetName :: - (HTMLAppletElementClass self) => self -> String -> IO () -htmlAppletElementSetName self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_applet_element_set_name #} - (toHTMLAppletElement self) - valPtr +setName :: + (MonadIO m, HTMLAppletElementClass self, GlibString string) => + self -> string -> m () +setName self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_applet_element_set_name #} + (toHTMLAppletElement self) + valPtr) -htmlAppletElementGetName :: - (HTMLAppletElementClass self) => self -> IO String -htmlAppletElementGetName self - = ({# call webkit_dom_html_applet_element_get_name #} - (toHTMLAppletElement self)) - >>= - readUTFString +getName :: + (MonadIO m, HTMLAppletElementClass self, GlibString string) => + self -> m string +getName self + = liftIO + (({# call webkit_dom_html_applet_element_get_name #} + (toHTMLAppletElement self)) + >>= + readUTFString) -htmlAppletElementSetObject :: - (HTMLAppletElementClass self) => self -> String -> IO () -htmlAppletElementSetObject self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_applet_element_set_object #} - (toHTMLAppletElement self) - valPtr +setObject :: + (MonadIO m, HTMLAppletElementClass self, GlibString string) => + self -> string -> m () +setObject self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_applet_element_set_object #} + (toHTMLAppletElement self) + valPtr) -htmlAppletElementGetObject :: - (HTMLAppletElementClass self) => self -> IO String -htmlAppletElementGetObject self - = ({# call webkit_dom_html_applet_element_get_object #} - (toHTMLAppletElement self)) - >>= - readUTFString +getObject :: + (MonadIO m, HTMLAppletElementClass self, GlibString string) => + self -> m string +getObject self + = liftIO + (({# call webkit_dom_html_applet_element_get_object #} + (toHTMLAppletElement self)) + >>= + readUTFString) -htmlAppletElementSetVspace :: - (HTMLAppletElementClass self) => self -> Int -> IO () -htmlAppletElementSetVspace self val - = {# call webkit_dom_html_applet_element_set_vspace #} - (toHTMLAppletElement self) - (fromIntegral val) +setVspace :: + (MonadIO m, HTMLAppletElementClass self) => self -> Int -> m () +setVspace self val + = liftIO + ({# call webkit_dom_html_applet_element_set_vspace #} + (toHTMLAppletElement self) + (fromIntegral val)) -htmlAppletElementGetVspace :: - (HTMLAppletElementClass self) => self -> IO Int -htmlAppletElementGetVspace self - = fromIntegral <$> - ({# call webkit_dom_html_applet_element_get_vspace #} - (toHTMLAppletElement self)) +getVspace :: + (MonadIO m, HTMLAppletElementClass self) => self -> m Int +getVspace self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_applet_element_get_vspace #} + (toHTMLAppletElement self))) -htmlAppletElementSetWidth :: - (HTMLAppletElementClass self) => self -> String -> IO () -htmlAppletElementSetWidth self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_applet_element_set_width #} - (toHTMLAppletElement self) - valPtr +setWidth :: + (MonadIO m, HTMLAppletElementClass self, GlibString string) => + self -> string -> m () +setWidth self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_applet_element_set_width #} + (toHTMLAppletElement self) + valPtr) -htmlAppletElementGetWidth :: - (HTMLAppletElementClass self) => self -> IO String -htmlAppletElementGetWidth self - = ({# call webkit_dom_html_applet_element_get_width #} - (toHTMLAppletElement self)) - >>= - readUTFString +getWidth :: + (MonadIO m, HTMLAppletElementClass self, GlibString string) => + self -> m string +getWidth self + = liftIO + (({# call webkit_dom_html_applet_element_get_width #} + (toHTMLAppletElement self)) + >>= + readUTFString) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLAreaElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLAreaElement.chs --- a/Graphics/UI/Gtk/WebKit/DOM/HTMLAreaElement.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLAreaElement.chs @@ -1,192 +1,295 @@ -module Graphics.UI.Gtk.WebKit.DOM.HTMLAreaElement - (htmlAreaElementSetAlt, htmlAreaElementGetAlt, - htmlAreaElementSetCoords, htmlAreaElementGetCoords, - htmlAreaElementSetHref, htmlAreaElementGetHref, - htmlAreaElementSetNoHref, htmlAreaElementGetNoHref, - htmlAreaElementSetPing, htmlAreaElementGetPing, - htmlAreaElementSetShape, htmlAreaElementGetShape, - htmlAreaElementSetTarget, htmlAreaElementGetTarget, - htmlAreaElementGetHash, htmlAreaElementGetHost, - htmlAreaElementGetHostname, htmlAreaElementGetPathname, - htmlAreaElementGetPort, htmlAreaElementGetProtocol, - htmlAreaElementGetSearch, HTMLAreaElement, HTMLAreaElementClass, - castToHTMLAreaElement, gTypeHTMLAreaElement, toHTMLAreaElement) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.HTMLAreaElement( +setAlt, +getAlt, +setCoords, +getCoords, +setHref, +getHref, +setNoHref, +getNoHref, +setPing, +getPing, +#if WEBKIT_CHECK_VERSION(99,0,0) +setRel, +getRel, +#endif +setShape, +getShape, +setTarget, +getTarget, +getHash, +getHost, +getHostname, +getPathname, +getPort, +getProtocol, +getSearch, +#if WEBKIT_CHECK_VERSION(99,0,0) +getRelList, +#endif +HTMLAreaElement, +castToHTMLAreaElement, +gTypeHTMLAreaElement, +HTMLAreaElementClass, +toHTMLAreaElement, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -htmlAreaElementSetAlt :: - (HTMLAreaElementClass self) => self -> String -> IO () -htmlAreaElementSetAlt self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_area_element_set_alt #} - (toHTMLAreaElement self) - valPtr +setAlt :: + (MonadIO m, HTMLAreaElementClass self, GlibString string) => + self -> string -> m () +setAlt self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_area_element_set_alt #} + (toHTMLAreaElement self) + valPtr) -htmlAreaElementGetAlt :: - (HTMLAreaElementClass self) => self -> IO String -htmlAreaElementGetAlt self - = ({# call webkit_dom_html_area_element_get_alt #} - (toHTMLAreaElement self)) - >>= - readUTFString +getAlt :: + (MonadIO m, HTMLAreaElementClass self, GlibString string) => + self -> m string +getAlt self + = liftIO + (({# call webkit_dom_html_area_element_get_alt #} + (toHTMLAreaElement self)) + >>= + readUTFString) -htmlAreaElementSetCoords :: - (HTMLAreaElementClass self) => self -> String -> IO () -htmlAreaElementSetCoords self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_area_element_set_coords #} - (toHTMLAreaElement self) - valPtr +setCoords :: + (MonadIO m, HTMLAreaElementClass self, GlibString string) => + self -> string -> m () +setCoords self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_area_element_set_coords #} + (toHTMLAreaElement self) + valPtr) -htmlAreaElementGetCoords :: - (HTMLAreaElementClass self) => self -> IO String -htmlAreaElementGetCoords self - = ({# call webkit_dom_html_area_element_get_coords #} - (toHTMLAreaElement self)) - >>= - readUTFString +getCoords :: + (MonadIO m, HTMLAreaElementClass self, GlibString string) => + self -> m string +getCoords self + = liftIO + (({# call webkit_dom_html_area_element_get_coords #} + (toHTMLAreaElement self)) + >>= + readUTFString) -htmlAreaElementSetHref :: - (HTMLAreaElementClass self) => self -> String -> IO () -htmlAreaElementSetHref self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_area_element_set_href #} - (toHTMLAreaElement self) - valPtr +setHref :: + (MonadIO m, HTMLAreaElementClass self, GlibString string) => + self -> string -> m () +setHref self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_area_element_set_href #} + (toHTMLAreaElement self) + valPtr) -htmlAreaElementGetHref :: - (HTMLAreaElementClass self) => self -> IO String -htmlAreaElementGetHref self - = ({# call webkit_dom_html_area_element_get_href #} - (toHTMLAreaElement self)) - >>= - readUTFString +getHref :: + (MonadIO m, HTMLAreaElementClass self, GlibString string) => + self -> m string +getHref self + = liftIO + (({# call webkit_dom_html_area_element_get_href #} + (toHTMLAreaElement self)) + >>= + readUTFString) -htmlAreaElementSetNoHref :: - (HTMLAreaElementClass self) => self -> Bool -> IO () -htmlAreaElementSetNoHref self val - = {# call webkit_dom_html_area_element_set_no_href #} - (toHTMLAreaElement self) - (fromBool val) +setNoHref :: + (MonadIO m, HTMLAreaElementClass self) => self -> Bool -> m () +setNoHref self val + = liftIO + ({# call webkit_dom_html_area_element_set_no_href #} + (toHTMLAreaElement self) + (fromBool val)) -htmlAreaElementGetNoHref :: - (HTMLAreaElementClass self) => self -> IO Bool -htmlAreaElementGetNoHref self - = toBool <$> - ({# call webkit_dom_html_area_element_get_no_href #} - (toHTMLAreaElement self)) +getNoHref :: + (MonadIO m, HTMLAreaElementClass self) => self -> m Bool +getNoHref self + = liftIO + (toBool <$> + ({# call webkit_dom_html_area_element_get_no_href #} + (toHTMLAreaElement self))) -htmlAreaElementSetPing :: - (HTMLAreaElementClass self) => self -> String -> IO () -htmlAreaElementSetPing self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_area_element_set_ping #} - (toHTMLAreaElement self) - valPtr +setPing :: + (MonadIO m, HTMLAreaElementClass self, GlibString string) => + self -> string -> m () +setPing self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_area_element_set_ping #} + (toHTMLAreaElement self) + valPtr) -htmlAreaElementGetPing :: - (HTMLAreaElementClass self) => self -> IO String -htmlAreaElementGetPing self - = ({# call webkit_dom_html_area_element_get_ping #} - (toHTMLAreaElement self)) - >>= - readUTFString +getPing :: + (MonadIO m, HTMLAreaElementClass self, GlibString string) => + self -> m string +getPing self + = liftIO + (({# call webkit_dom_html_area_element_get_ping #} + (toHTMLAreaElement self)) + >>= + readUTFString) + +#if WEBKIT_CHECK_VERSION(99,0,0) +setRel :: + (MonadIO m, HTMLAreaElementClass self, GlibString string) => + self -> string -> m () +setRel self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_area_element_set_rel #} + (toHTMLAreaElement self) + valPtr) -htmlAreaElementSetShape :: - (HTMLAreaElementClass self) => self -> String -> IO () -htmlAreaElementSetShape self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_area_element_set_shape #} - (toHTMLAreaElement self) - valPtr +getRel :: + (MonadIO m, HTMLAreaElementClass self, GlibString string) => + self -> m string +getRel self + = liftIO + (({# call webkit_dom_html_area_element_get_rel #} + (toHTMLAreaElement self)) + >>= + readUTFString) +#endif -htmlAreaElementGetShape :: - (HTMLAreaElementClass self) => self -> IO String -htmlAreaElementGetShape self - = ({# call webkit_dom_html_area_element_get_shape #} - (toHTMLAreaElement self)) - >>= - readUTFString +setShape :: + (MonadIO m, HTMLAreaElementClass self, GlibString string) => + self -> string -> m () +setShape self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_area_element_set_shape #} + (toHTMLAreaElement self) + valPtr) -htmlAreaElementSetTarget :: - (HTMLAreaElementClass self) => self -> String -> IO () -htmlAreaElementSetTarget self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_area_element_set_target #} - (toHTMLAreaElement self) - valPtr +getShape :: + (MonadIO m, HTMLAreaElementClass self, GlibString string) => + self -> m string +getShape self + = liftIO + (({# call webkit_dom_html_area_element_get_shape #} + (toHTMLAreaElement self)) + >>= + readUTFString) -htmlAreaElementGetTarget :: - (HTMLAreaElementClass self) => self -> IO String -htmlAreaElementGetTarget self - = ({# call webkit_dom_html_area_element_get_target #} - (toHTMLAreaElement self)) - >>= - readUTFString +setTarget :: + (MonadIO m, HTMLAreaElementClass self, GlibString string) => + self -> string -> m () +setTarget self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_area_element_set_target #} + (toHTMLAreaElement self) + valPtr) -htmlAreaElementGetHash :: - (HTMLAreaElementClass self) => self -> IO String -htmlAreaElementGetHash self - = ({# call webkit_dom_html_area_element_get_hash #} - (toHTMLAreaElement self)) - >>= - readUTFString +getTarget :: + (MonadIO m, HTMLAreaElementClass self, GlibString string) => + self -> m string +getTarget self + = liftIO + (({# call webkit_dom_html_area_element_get_target #} + (toHTMLAreaElement self)) + >>= + readUTFString) -htmlAreaElementGetHost :: - (HTMLAreaElementClass self) => self -> IO String -htmlAreaElementGetHost self - = ({# call webkit_dom_html_area_element_get_host #} - (toHTMLAreaElement self)) - >>= - readUTFString +getHash :: + (MonadIO m, HTMLAreaElementClass self, GlibString string) => + self -> m string +getHash self + = liftIO + (({# call webkit_dom_html_area_element_get_hash #} + (toHTMLAreaElement self)) + >>= + readUTFString) -htmlAreaElementGetHostname :: - (HTMLAreaElementClass self) => self -> IO String -htmlAreaElementGetHostname self - = ({# call webkit_dom_html_area_element_get_hostname #} - (toHTMLAreaElement self)) - >>= - readUTFString +getHost :: + (MonadIO m, HTMLAreaElementClass self, GlibString string) => + self -> m string +getHost self + = liftIO + (({# call webkit_dom_html_area_element_get_host #} + (toHTMLAreaElement self)) + >>= + readUTFString) -htmlAreaElementGetPathname :: - (HTMLAreaElementClass self) => self -> IO String -htmlAreaElementGetPathname self - = ({# call webkit_dom_html_area_element_get_pathname #} - (toHTMLAreaElement self)) - >>= - readUTFString +getHostname :: + (MonadIO m, HTMLAreaElementClass self, GlibString string) => + self -> m string +getHostname self + = liftIO + (({# call webkit_dom_html_area_element_get_hostname #} + (toHTMLAreaElement self)) + >>= + readUTFString) -htmlAreaElementGetPort :: - (HTMLAreaElementClass self) => self -> IO String -htmlAreaElementGetPort self - = ({# call webkit_dom_html_area_element_get_port #} - (toHTMLAreaElement self)) - >>= - readUTFString +getPathname :: + (MonadIO m, HTMLAreaElementClass self, GlibString string) => + self -> m string +getPathname self + = liftIO + (({# call webkit_dom_html_area_element_get_pathname #} + (toHTMLAreaElement self)) + >>= + readUTFString) -htmlAreaElementGetProtocol :: - (HTMLAreaElementClass self) => self -> IO String -htmlAreaElementGetProtocol self - = ({# call webkit_dom_html_area_element_get_protocol #} - (toHTMLAreaElement self)) - >>= - readUTFString +getPort :: + (MonadIO m, HTMLAreaElementClass self, GlibString string) => + self -> m string +getPort self + = liftIO + (({# call webkit_dom_html_area_element_get_port #} + (toHTMLAreaElement self)) + >>= + readUTFString) -htmlAreaElementGetSearch :: - (HTMLAreaElementClass self) => self -> IO String -htmlAreaElementGetSearch self - = ({# call webkit_dom_html_area_element_get_search #} - (toHTMLAreaElement self)) - >>= - readUTFString +getProtocol :: + (MonadIO m, HTMLAreaElementClass self, GlibString string) => + self -> m string +getProtocol self + = liftIO + (({# call webkit_dom_html_area_element_get_protocol #} + (toHTMLAreaElement self)) + >>= + readUTFString) + +getSearch :: + (MonadIO m, HTMLAreaElementClass self, GlibString string) => + self -> m string +getSearch self + = liftIO + (({# call webkit_dom_html_area_element_get_search #} + (toHTMLAreaElement self)) + >>= + readUTFString) + +#if WEBKIT_CHECK_VERSION(99,0,0) +getRelList :: + (MonadIO m, HTMLAreaElementClass self) => + self -> m (Maybe DOMTokenList) +getRelList self + = liftIO + (maybeNull (makeNewGObject mkDOMTokenList) + ({# call webkit_dom_html_area_element_get_rel_list #} + (toHTMLAreaElement self))) +#endif diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLBRElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLBRElement.chs --- a/Graphics/UI/Gtk/WebKit/DOM/HTMLBRElement.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLBRElement.chs @@ -1,28 +1,44 @@ -module Graphics.UI.Gtk.WebKit.DOM.HTMLBRElement - (htmlbrElementSetClear, htmlbrElementGetClear, HTMLBRElement, - HTMLBRElementClass, castToHTMLBRElement, gTypeHTMLBRElement, - toHTMLBRElement) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.HTMLBRElement( +setClear, +getClear, +HTMLBRElement, +castToHTMLBRElement, +gTypeHTMLBRElement, +HTMLBRElementClass, +toHTMLBRElement, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -htmlbrElementSetClear :: - (HTMLBRElementClass self) => self -> String -> IO () -htmlbrElementSetClear self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_htmlbr_element_set_clear #} - (toHTMLBRElement self) - valPtr +setClear :: + (MonadIO m, HTMLBRElementClass self, GlibString string) => + self -> string -> m () +setClear self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_htmlbr_element_set_clear #} + (toHTMLBRElement self) + valPtr) -htmlbrElementGetClear :: - (HTMLBRElementClass self) => self -> IO String -htmlbrElementGetClear self - = ({# call webkit_dom_htmlbr_element_get_clear #} - (toHTMLBRElement self)) - >>= - readUTFString +getClear :: + (MonadIO m, HTMLBRElementClass self, GlibString string) => + self -> m string +getClear self + = liftIO + (({# call webkit_dom_htmlbr_element_get_clear #} + (toHTMLBRElement self)) + >>= + readUTFString) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLBaseElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLBaseElement.chs --- a/Graphics/UI/Gtk/WebKit/DOM/HTMLBaseElement.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLBaseElement.chs @@ -1,46 +1,67 @@ -module Graphics.UI.Gtk.WebKit.DOM.HTMLBaseElement - (htmlBaseElementSetHref, htmlBaseElementGetHref, - htmlBaseElementSetTarget, htmlBaseElementGetTarget, - HTMLBaseElement, HTMLBaseElementClass, castToHTMLBaseElement, - gTypeHTMLBaseElement, toHTMLBaseElement) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.HTMLBaseElement( +setHref, +getHref, +setTarget, +getTarget, +HTMLBaseElement, +castToHTMLBaseElement, +gTypeHTMLBaseElement, +HTMLBaseElementClass, +toHTMLBaseElement, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -htmlBaseElementSetHref :: - (HTMLBaseElementClass self) => self -> String -> IO () -htmlBaseElementSetHref self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_base_element_set_href #} - (toHTMLBaseElement self) - valPtr +setHref :: + (MonadIO m, HTMLBaseElementClass self, GlibString string) => + self -> (Maybe string) -> m () +setHref self val + = liftIO + (maybeWith withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_base_element_set_href #} + (toHTMLBaseElement self) + valPtr) -htmlBaseElementGetHref :: - (HTMLBaseElementClass self) => self -> IO String -htmlBaseElementGetHref self - = ({# call webkit_dom_html_base_element_get_href #} - (toHTMLBaseElement self)) - >>= - readUTFString +getHref :: + (MonadIO m, HTMLBaseElementClass self, GlibString string) => + self -> m (Maybe string) +getHref self + = liftIO + (({# call webkit_dom_html_base_element_get_href #} + (toHTMLBaseElement self)) + >>= + maybePeek readUTFString) -htmlBaseElementSetTarget :: - (HTMLBaseElementClass self) => self -> String -> IO () -htmlBaseElementSetTarget self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_base_element_set_target #} - (toHTMLBaseElement self) - valPtr +setTarget :: + (MonadIO m, HTMLBaseElementClass self, GlibString string) => + self -> string -> m () +setTarget self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_base_element_set_target #} + (toHTMLBaseElement self) + valPtr) -htmlBaseElementGetTarget :: - (HTMLBaseElementClass self) => self -> IO String -htmlBaseElementGetTarget self - = ({# call webkit_dom_html_base_element_get_target #} - (toHTMLBaseElement self)) - >>= - readUTFString +getTarget :: + (MonadIO m, HTMLBaseElementClass self, GlibString string) => + self -> m string +getTarget self + = liftIO + (({# call webkit_dom_html_base_element_get_target #} + (toHTMLBaseElement self)) + >>= + readUTFString) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLBaseFontElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLBaseFontElement.chs --- a/Graphics/UI/Gtk/WebKit/DOM/HTMLBaseFontElement.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLBaseFontElement.chs @@ -1,62 +1,85 @@ -module Graphics.UI.Gtk.WebKit.DOM.HTMLBaseFontElement - (htmlBaseFontElementSetColor, htmlBaseFontElementGetColor, - htmlBaseFontElementSetFace, htmlBaseFontElementGetFace, - htmlBaseFontElementSetSize, htmlBaseFontElementGetSize, - HTMLBaseFontElement, HTMLBaseFontElementClass, - castToHTMLBaseFontElement, gTypeHTMLBaseFontElement, - toHTMLBaseFontElement) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.HTMLBaseFontElement( +setColor, +getColor, +setFace, +getFace, +setSize, +getSize, +HTMLBaseFontElement, +castToHTMLBaseFontElement, +gTypeHTMLBaseFontElement, +HTMLBaseFontElementClass, +toHTMLBaseFontElement, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -htmlBaseFontElementSetColor :: - (HTMLBaseFontElementClass self) => self -> String -> IO () -htmlBaseFontElementSetColor self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_base_font_element_set_color #} - (toHTMLBaseFontElement self) - valPtr +setColor :: + (MonadIO m, HTMLBaseFontElementClass self, GlibString string) => + self -> string -> m () +setColor self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_base_font_element_set_color #} + (toHTMLBaseFontElement self) + valPtr) -htmlBaseFontElementGetColor :: - (HTMLBaseFontElementClass self) => self -> IO String -htmlBaseFontElementGetColor self - = ({# call webkit_dom_html_base_font_element_get_color #} - (toHTMLBaseFontElement self)) - >>= - readUTFString +getColor :: + (MonadIO m, HTMLBaseFontElementClass self, GlibString string) => + self -> m string +getColor self + = liftIO + (({# call webkit_dom_html_base_font_element_get_color #} + (toHTMLBaseFontElement self)) + >>= + readUTFString) -htmlBaseFontElementSetFace :: - (HTMLBaseFontElementClass self) => self -> String -> IO () -htmlBaseFontElementSetFace self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_base_font_element_set_face #} - (toHTMLBaseFontElement self) - valPtr +setFace :: + (MonadIO m, HTMLBaseFontElementClass self, GlibString string) => + self -> string -> m () +setFace self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_base_font_element_set_face #} + (toHTMLBaseFontElement self) + valPtr) -htmlBaseFontElementGetFace :: - (HTMLBaseFontElementClass self) => self -> IO String -htmlBaseFontElementGetFace self - = ({# call webkit_dom_html_base_font_element_get_face #} - (toHTMLBaseFontElement self)) - >>= - readUTFString +getFace :: + (MonadIO m, HTMLBaseFontElementClass self, GlibString string) => + self -> m string +getFace self + = liftIO + (({# call webkit_dom_html_base_font_element_get_face #} + (toHTMLBaseFontElement self)) + >>= + readUTFString) -htmlBaseFontElementSetSize :: - (HTMLBaseFontElementClass self) => self -> Int -> IO () -htmlBaseFontElementSetSize self val - = {# call webkit_dom_html_base_font_element_set_size #} - (toHTMLBaseFontElement self) - (fromIntegral val) +setSize :: + (MonadIO m, HTMLBaseFontElementClass self) => self -> Int -> m () +setSize self val + = liftIO + ({# call webkit_dom_html_base_font_element_set_size #} + (toHTMLBaseFontElement self) + (fromIntegral val)) -htmlBaseFontElementGetSize :: - (HTMLBaseFontElementClass self) => self -> IO Int -htmlBaseFontElementGetSize self - = fromIntegral <$> - ({# call webkit_dom_html_base_font_element_get_size #} - (toHTMLBaseFontElement self)) +getSize :: + (MonadIO m, HTMLBaseFontElementClass self) => self -> m Int +getSize self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_base_font_element_get_size #} + (toHTMLBaseFontElement self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLBodyElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLBodyElement.chs --- a/Graphics/UI/Gtk/WebKit/DOM/HTMLBodyElement.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLBodyElement.chs @@ -1,182 +1,216 @@ -module Graphics.UI.Gtk.WebKit.DOM.HTMLBodyElement - (htmlBodyElementSetALink, htmlBodyElementGetALink, - htmlBodyElementSetBackground, htmlBodyElementGetBackground, - htmlBodyElementSetBgColor, htmlBodyElementGetBgColor, - htmlBodyElementSetLink, htmlBodyElementGetLink, - htmlBodyElementSetText, htmlBodyElementGetText, - htmlBodyElementSetVLink, htmlBodyElementGetVLink, - htmlBodyElementOnbeforeunload, htmlBodyElementOnhashchange, - htmlBodyElementOnmessage, htmlBodyElementOnoffline, - htmlBodyElementOnonline, htmlBodyElementOnpopstate, - htmlBodyElementOnresize, htmlBodyElementOnstorage, - htmlBodyElementOnunload, htmlBodyElementOnorientationchange, - htmlBodyElementOnblur, htmlBodyElementOnerror, - htmlBodyElementOnfocus, htmlBodyElementOnload, HTMLBodyElement, - HTMLBodyElementClass, castToHTMLBodyElement, gTypeHTMLBodyElement, - toHTMLBodyElement) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.HTMLBodyElement( +setALink, +getALink, +setBackground, +getBackground, +setBgColor, +getBgColor, +setLink, +getLink, +setText, +getText, +setVLink, +getVLink, +beforeUnload, +hashChange, +message, +offline, +online, +popState, +resize, +storage, +unload, +orientationChange, +blur, +error, +focus, +load, +HTMLBodyElement, +castToHTMLBodyElement, +gTypeHTMLBodyElement, +HTMLBodyElementClass, +toHTMLBodyElement, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -htmlBodyElementSetALink :: - (HTMLBodyElementClass self) => self -> String -> IO () -htmlBodyElementSetALink self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_body_element_set_a_link #} - (toHTMLBodyElement self) - valPtr +setALink :: + (MonadIO m, HTMLBodyElementClass self, GlibString string) => + self -> string -> m () +setALink self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_body_element_set_a_link #} + (toHTMLBodyElement self) + valPtr) -htmlBodyElementGetALink :: - (HTMLBodyElementClass self) => self -> IO String -htmlBodyElementGetALink self - = ({# call webkit_dom_html_body_element_get_a_link #} - (toHTMLBodyElement self)) - >>= - readUTFString +getALink :: + (MonadIO m, HTMLBodyElementClass self, GlibString string) => + self -> m string +getALink self + = liftIO + (({# call webkit_dom_html_body_element_get_a_link #} + (toHTMLBodyElement self)) + >>= + readUTFString) -htmlBodyElementSetBackground :: - (HTMLBodyElementClass self) => self -> String -> IO () -htmlBodyElementSetBackground self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_body_element_set_background #} - (toHTMLBodyElement self) - valPtr +setBackground :: + (MonadIO m, HTMLBodyElementClass self, GlibString string) => + self -> string -> m () +setBackground self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_body_element_set_background #} + (toHTMLBodyElement self) + valPtr) -htmlBodyElementGetBackground :: - (HTMLBodyElementClass self) => self -> IO String -htmlBodyElementGetBackground self - = ({# call webkit_dom_html_body_element_get_background #} - (toHTMLBodyElement self)) - >>= - readUTFString +getBackground :: + (MonadIO m, HTMLBodyElementClass self, GlibString string) => + self -> m string +getBackground self + = liftIO + (({# call webkit_dom_html_body_element_get_background #} + (toHTMLBodyElement self)) + >>= + readUTFString) -htmlBodyElementSetBgColor :: - (HTMLBodyElementClass self) => self -> String -> IO () -htmlBodyElementSetBgColor self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_body_element_set_bg_color #} - (toHTMLBodyElement self) - valPtr +setBgColor :: + (MonadIO m, HTMLBodyElementClass self, GlibString string) => + self -> string -> m () +setBgColor self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_body_element_set_bg_color #} + (toHTMLBodyElement self) + valPtr) -htmlBodyElementGetBgColor :: - (HTMLBodyElementClass self) => self -> IO String -htmlBodyElementGetBgColor self - = ({# call webkit_dom_html_body_element_get_bg_color #} - (toHTMLBodyElement self)) - >>= - readUTFString +getBgColor :: + (MonadIO m, HTMLBodyElementClass self, GlibString string) => + self -> m string +getBgColor self + = liftIO + (({# call webkit_dom_html_body_element_get_bg_color #} + (toHTMLBodyElement self)) + >>= + readUTFString) -htmlBodyElementSetLink :: - (HTMLBodyElementClass self) => self -> String -> IO () -htmlBodyElementSetLink self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_body_element_set_link #} - (toHTMLBodyElement self) - valPtr +setLink :: + (MonadIO m, HTMLBodyElementClass self, GlibString string) => + self -> string -> m () +setLink self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_body_element_set_link #} + (toHTMLBodyElement self) + valPtr) -htmlBodyElementGetLink :: - (HTMLBodyElementClass self) => self -> IO String -htmlBodyElementGetLink self - = ({# call webkit_dom_html_body_element_get_link #} - (toHTMLBodyElement self)) - >>= - readUTFString +getLink :: + (MonadIO m, HTMLBodyElementClass self, GlibString string) => + self -> m string +getLink self + = liftIO + (({# call webkit_dom_html_body_element_get_link #} + (toHTMLBodyElement self)) + >>= + readUTFString) -htmlBodyElementSetText :: - (HTMLBodyElementClass self) => self -> String -> IO () -htmlBodyElementSetText self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_body_element_set_text #} - (toHTMLBodyElement self) - valPtr +setText :: + (MonadIO m, HTMLBodyElementClass self, GlibString string) => + self -> string -> m () +setText self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_body_element_set_text #} + (toHTMLBodyElement self) + valPtr) -htmlBodyElementGetText :: - (HTMLBodyElementClass self) => self -> IO String -htmlBodyElementGetText self - = ({# call webkit_dom_html_body_element_get_text #} - (toHTMLBodyElement self)) - >>= - readUTFString +getText :: + (MonadIO m, HTMLBodyElementClass self, GlibString string) => + self -> m string +getText self + = liftIO + (({# call webkit_dom_html_body_element_get_text #} + (toHTMLBodyElement self)) + >>= + readUTFString) -htmlBodyElementSetVLink :: - (HTMLBodyElementClass self) => self -> String -> IO () -htmlBodyElementSetVLink self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_body_element_set_v_link #} - (toHTMLBodyElement self) - valPtr +setVLink :: + (MonadIO m, HTMLBodyElementClass self, GlibString string) => + self -> string -> m () +setVLink self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_body_element_set_v_link #} + (toHTMLBodyElement self) + valPtr) -htmlBodyElementGetVLink :: - (HTMLBodyElementClass self) => self -> IO String -htmlBodyElementGetVLink self - = ({# call webkit_dom_html_body_element_get_v_link #} - (toHTMLBodyElement self)) - >>= - readUTFString +getVLink :: + (MonadIO m, HTMLBodyElementClass self, GlibString string) => + self -> m string +getVLink self + = liftIO + (({# call webkit_dom_html_body_element_get_v_link #} + (toHTMLBodyElement self)) + >>= + readUTFString) -htmlBodyElementOnbeforeunload :: - (HTMLBodyElementClass self) => Signal self (EventM UIEvent self ()) -htmlBodyElementOnbeforeunload = (connect "beforeunload") +beforeUnload :: (HTMLBodyElementClass self) => EventName self Event +beforeUnload = EventName "beforeunload" -htmlBodyElementOnhashchange :: - (HTMLBodyElementClass self) => Signal self (EventM UIEvent self ()) -htmlBodyElementOnhashchange = (connect "hashchange") +hashChange :: (HTMLBodyElementClass self) => EventName self Event +hashChange = EventName "hashchange" -htmlBodyElementOnmessage :: - (HTMLBodyElementClass self) => Signal self (EventM UIEvent self ()) -htmlBodyElementOnmessage = (connect "message") +message :: (HTMLBodyElementClass self) => EventName self Event +message = EventName "message" -htmlBodyElementOnoffline :: - (HTMLBodyElementClass self) => Signal self (EventM UIEvent self ()) -htmlBodyElementOnoffline = (connect "offline") +offline :: (HTMLBodyElementClass self) => EventName self Event +offline = EventName "offline" -htmlBodyElementOnonline :: - (HTMLBodyElementClass self) => Signal self (EventM UIEvent self ()) -htmlBodyElementOnonline = (connect "online") +online :: (HTMLBodyElementClass self) => EventName self Event +online = EventName "online" -htmlBodyElementOnpopstate :: - (HTMLBodyElementClass self) => Signal self (EventM UIEvent self ()) -htmlBodyElementOnpopstate = (connect "popstate") +popState :: (HTMLBodyElementClass self) => EventName self Event +popState = EventName "popstate" -htmlBodyElementOnresize :: - (HTMLBodyElementClass self) => Signal self (EventM UIEvent self ()) -htmlBodyElementOnresize = (connect "resize") +resize :: (HTMLBodyElementClass self) => EventName self UIEvent +resize = EventName "resize" -htmlBodyElementOnstorage :: - (HTMLBodyElementClass self) => Signal self (EventM UIEvent self ()) -htmlBodyElementOnstorage = (connect "storage") +storage :: (HTMLBodyElementClass self) => EventName self Event +storage = EventName "storage" -htmlBodyElementOnunload :: - (HTMLBodyElementClass self) => Signal self (EventM UIEvent self ()) -htmlBodyElementOnunload = (connect "unload") +unload :: (HTMLBodyElementClass self) => EventName self UIEvent +unload = EventName "unload" -htmlBodyElementOnorientationchange :: - (HTMLBodyElementClass self) => - Signal self (EventM UIEvent self ()) -htmlBodyElementOnorientationchange = (connect "orientationchange") +orientationChange :: + (HTMLBodyElementClass self) => EventName self Event +orientationChange = EventName "orientationchange" -htmlBodyElementOnblur :: - (HTMLBodyElementClass self) => Signal self (EventM UIEvent self ()) -htmlBodyElementOnblur = (connect "blur") +blur :: (HTMLBodyElementClass self) => EventName self UIEvent +blur = EventName "blur" -htmlBodyElementOnerror :: - (HTMLBodyElementClass self) => Signal self (EventM UIEvent self ()) -htmlBodyElementOnerror = (connect "error") +error :: (HTMLBodyElementClass self) => EventName self UIEvent +error = EventName "error" -htmlBodyElementOnfocus :: - (HTMLBodyElementClass self) => Signal self (EventM UIEvent self ()) -htmlBodyElementOnfocus = (connect "focus") +focus :: (HTMLBodyElementClass self) => EventName self UIEvent +focus = EventName "focus" -htmlBodyElementOnload :: - (HTMLBodyElementClass self) => Signal self (EventM UIEvent self ()) -htmlBodyElementOnload = (connect "load") +load :: (HTMLBodyElementClass self) => EventName self UIEvent +load = EventName "load" diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLButtonElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLButtonElement.chs --- a/Graphics/UI/Gtk/WebKit/DOM/HTMLButtonElement.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLButtonElement.chs @@ -1,220 +1,284 @@ -module Graphics.UI.Gtk.WebKit.DOM.HTMLButtonElement - (htmlButtonElementCheckValidity, - htmlButtonElementSetCustomValidity, htmlButtonElementSetAutofocus, - htmlButtonElementGetAutofocus, htmlButtonElementSetDisabled, - htmlButtonElementGetDisabled, htmlButtonElementGetForm, - htmlButtonElementSetFormAction, htmlButtonElementGetFormAction, - htmlButtonElementSetFormEnctype, htmlButtonElementGetFormEnctype, - htmlButtonElementSetFormMethod, htmlButtonElementGetFormMethod, - htmlButtonElementSetFormNoValidate, - htmlButtonElementGetFormNoValidate, htmlButtonElementSetFormTarget, - htmlButtonElementGetFormTarget, htmlButtonElementSetName, - htmlButtonElementGetName, htmlButtonElementSetValue, - htmlButtonElementGetValue, htmlButtonElementGetWillValidate, - htmlButtonElementGetValidity, - htmlButtonElementGetValidationMessage, htmlButtonElementGetLabels, - HTMLButtonElement, HTMLButtonElementClass, castToHTMLButtonElement, - gTypeHTMLButtonElement, toHTMLButtonElement) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.HTMLButtonElement( +checkValidity, +setCustomValidity, +setAutofocus, +getAutofocus, +setDisabled, +getDisabled, +getForm, +setFormAction, +getFormAction, +setFormEnctype, +getFormEnctype, +setFormMethod, +getFormMethod, +setFormNoValidate, +getFormNoValidate, +setFormTarget, +getFormTarget, +setName, +getName, +setValue, +getValue, +getWillValidate, +getValidity, +getValidationMessage, +getLabels, +HTMLButtonElement, +castToHTMLButtonElement, +gTypeHTMLButtonElement, +HTMLButtonElementClass, +toHTMLButtonElement, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -htmlButtonElementCheckValidity :: - (HTMLButtonElementClass self) => self -> IO Bool -htmlButtonElementCheckValidity self - = toBool <$> - ({# call webkit_dom_html_button_element_check_validity #} - (toHTMLButtonElement self)) +checkValidity :: + (MonadIO m, HTMLButtonElementClass self) => self -> m Bool +checkValidity self + = liftIO + (toBool <$> + ({# call webkit_dom_html_button_element_check_validity #} + (toHTMLButtonElement self))) -htmlButtonElementSetCustomValidity :: - (HTMLButtonElementClass self) => self -> String -> IO () -htmlButtonElementSetCustomValidity self error - = withUTFString error $ - \ errorPtr -> - {# call webkit_dom_html_button_element_set_custom_validity #} - (toHTMLButtonElement self) - errorPtr +setCustomValidity :: + (MonadIO m, HTMLButtonElementClass self, GlibString string) => + self -> (Maybe string) -> m () +setCustomValidity self error + = liftIO + (maybeWith withUTFString error $ + \ errorPtr -> + {# call webkit_dom_html_button_element_set_custom_validity #} + (toHTMLButtonElement self) + errorPtr) -htmlButtonElementSetAutofocus :: - (HTMLButtonElementClass self) => self -> Bool -> IO () -htmlButtonElementSetAutofocus self val - = {# call webkit_dom_html_button_element_set_autofocus #} - (toHTMLButtonElement self) - (fromBool val) +setAutofocus :: + (MonadIO m, HTMLButtonElementClass self) => self -> Bool -> m () +setAutofocus self val + = liftIO + ({# call webkit_dom_html_button_element_set_autofocus #} + (toHTMLButtonElement self) + (fromBool val)) -htmlButtonElementGetAutofocus :: - (HTMLButtonElementClass self) => self -> IO Bool -htmlButtonElementGetAutofocus self - = toBool <$> - ({# call webkit_dom_html_button_element_get_autofocus #} - (toHTMLButtonElement self)) +getAutofocus :: + (MonadIO m, HTMLButtonElementClass self) => self -> m Bool +getAutofocus self + = liftIO + (toBool <$> + ({# call webkit_dom_html_button_element_get_autofocus #} + (toHTMLButtonElement self))) -htmlButtonElementSetDisabled :: - (HTMLButtonElementClass self) => self -> Bool -> IO () -htmlButtonElementSetDisabled self val - = {# call webkit_dom_html_button_element_set_disabled #} - (toHTMLButtonElement self) - (fromBool val) +setDisabled :: + (MonadIO m, HTMLButtonElementClass self) => self -> Bool -> m () +setDisabled self val + = liftIO + ({# call webkit_dom_html_button_element_set_disabled #} + (toHTMLButtonElement self) + (fromBool val)) -htmlButtonElementGetDisabled :: - (HTMLButtonElementClass self) => self -> IO Bool -htmlButtonElementGetDisabled self - = toBool <$> - ({# call webkit_dom_html_button_element_get_disabled #} - (toHTMLButtonElement self)) +getDisabled :: + (MonadIO m, HTMLButtonElementClass self) => self -> m Bool +getDisabled self + = liftIO + (toBool <$> + ({# call webkit_dom_html_button_element_get_disabled #} + (toHTMLButtonElement self))) -htmlButtonElementGetForm :: - (HTMLButtonElementClass self) => self -> IO (Maybe HTMLFormElement) -htmlButtonElementGetForm self - = maybeNull (makeNewGObject mkHTMLFormElement) - ({# call webkit_dom_html_button_element_get_form #} - (toHTMLButtonElement self)) +getForm :: + (MonadIO m, HTMLButtonElementClass self) => + self -> m (Maybe HTMLFormElement) +getForm self + = liftIO + (maybeNull (makeNewGObject mkHTMLFormElement) + ({# call webkit_dom_html_button_element_get_form #} + (toHTMLButtonElement self))) -htmlButtonElementSetFormAction :: - (HTMLButtonElementClass self) => self -> String -> IO () -htmlButtonElementSetFormAction self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_button_element_set_form_action #} - (toHTMLButtonElement self) - valPtr +setFormAction :: + (MonadIO m, HTMLButtonElementClass self, GlibString string) => + self -> string -> m () +setFormAction self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_button_element_set_form_action #} + (toHTMLButtonElement self) + valPtr) -htmlButtonElementGetFormAction :: - (HTMLButtonElementClass self) => self -> IO String -htmlButtonElementGetFormAction self - = ({# call webkit_dom_html_button_element_get_form_action #} - (toHTMLButtonElement self)) - >>= - readUTFString +getFormAction :: + (MonadIO m, HTMLButtonElementClass self, GlibString string) => + self -> m string +getFormAction self + = liftIO + (({# call webkit_dom_html_button_element_get_form_action #} + (toHTMLButtonElement self)) + >>= + readUTFString) -htmlButtonElementSetFormEnctype :: - (HTMLButtonElementClass self) => self -> String -> IO () -htmlButtonElementSetFormEnctype self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_button_element_set_form_enctype #} - (toHTMLButtonElement self) - valPtr +setFormEnctype :: + (MonadIO m, HTMLButtonElementClass self, GlibString string) => + self -> (Maybe string) -> m () +setFormEnctype self val + = liftIO + (maybeWith withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_button_element_set_form_enctype #} + (toHTMLButtonElement self) + valPtr) -htmlButtonElementGetFormEnctype :: - (HTMLButtonElementClass self) => self -> IO String -htmlButtonElementGetFormEnctype self - = ({# call webkit_dom_html_button_element_get_form_enctype #} - (toHTMLButtonElement self)) - >>= - readUTFString +getFormEnctype :: + (MonadIO m, HTMLButtonElementClass self, GlibString string) => + self -> m (Maybe string) +getFormEnctype self + = liftIO + (({# call webkit_dom_html_button_element_get_form_enctype #} + (toHTMLButtonElement self)) + >>= + maybePeek readUTFString) -htmlButtonElementSetFormMethod :: - (HTMLButtonElementClass self) => self -> String -> IO () -htmlButtonElementSetFormMethod self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_button_element_set_form_method #} - (toHTMLButtonElement self) - valPtr +setFormMethod :: + (MonadIO m, HTMLButtonElementClass self, GlibString string) => + self -> (Maybe string) -> m () +setFormMethod self val + = liftIO + (maybeWith withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_button_element_set_form_method #} + (toHTMLButtonElement self) + valPtr) -htmlButtonElementGetFormMethod :: - (HTMLButtonElementClass self) => self -> IO String -htmlButtonElementGetFormMethod self - = ({# call webkit_dom_html_button_element_get_form_method #} - (toHTMLButtonElement self)) - >>= - readUTFString +getFormMethod :: + (MonadIO m, HTMLButtonElementClass self, GlibString string) => + self -> m (Maybe string) +getFormMethod self + = liftIO + (({# call webkit_dom_html_button_element_get_form_method #} + (toHTMLButtonElement self)) + >>= + maybePeek readUTFString) -htmlButtonElementSetFormNoValidate :: - (HTMLButtonElementClass self) => self -> Bool -> IO () -htmlButtonElementSetFormNoValidate self val - = {# call webkit_dom_html_button_element_set_form_no_validate #} - (toHTMLButtonElement self) - (fromBool val) +setFormNoValidate :: + (MonadIO m, HTMLButtonElementClass self) => self -> Bool -> m () +setFormNoValidate self val + = liftIO + ({# call webkit_dom_html_button_element_set_form_no_validate #} + (toHTMLButtonElement self) + (fromBool val)) -htmlButtonElementGetFormNoValidate :: - (HTMLButtonElementClass self) => self -> IO Bool -htmlButtonElementGetFormNoValidate self - = toBool <$> - ({# call webkit_dom_html_button_element_get_form_no_validate #} - (toHTMLButtonElement self)) +getFormNoValidate :: + (MonadIO m, HTMLButtonElementClass self) => self -> m Bool +getFormNoValidate self + = liftIO + (toBool <$> + ({# call webkit_dom_html_button_element_get_form_no_validate #} + (toHTMLButtonElement self))) -htmlButtonElementSetFormTarget :: - (HTMLButtonElementClass self) => self -> String -> IO () -htmlButtonElementSetFormTarget self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_button_element_set_form_target #} - (toHTMLButtonElement self) - valPtr +setFormTarget :: + (MonadIO m, HTMLButtonElementClass self, GlibString string) => + self -> string -> m () +setFormTarget self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_button_element_set_form_target #} + (toHTMLButtonElement self) + valPtr) -htmlButtonElementGetFormTarget :: - (HTMLButtonElementClass self) => self -> IO String -htmlButtonElementGetFormTarget self - = ({# call webkit_dom_html_button_element_get_form_target #} - (toHTMLButtonElement self)) - >>= - readUTFString +getFormTarget :: + (MonadIO m, HTMLButtonElementClass self, GlibString string) => + self -> m string +getFormTarget self + = liftIO + (({# call webkit_dom_html_button_element_get_form_target #} + (toHTMLButtonElement self)) + >>= + readUTFString) -htmlButtonElementSetName :: - (HTMLButtonElementClass self) => self -> String -> IO () -htmlButtonElementSetName self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_button_element_set_name #} - (toHTMLButtonElement self) - valPtr +setName :: + (MonadIO m, HTMLButtonElementClass self, GlibString string) => + self -> string -> m () +setName self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_button_element_set_name #} + (toHTMLButtonElement self) + valPtr) -htmlButtonElementGetName :: - (HTMLButtonElementClass self) => self -> IO String -htmlButtonElementGetName self - = ({# call webkit_dom_html_button_element_get_name #} - (toHTMLButtonElement self)) - >>= - readUTFString +getName :: + (MonadIO m, HTMLButtonElementClass self, GlibString string) => + self -> m string +getName self + = liftIO + (({# call webkit_dom_html_button_element_get_name #} + (toHTMLButtonElement self)) + >>= + readUTFString) -htmlButtonElementSetValue :: - (HTMLButtonElementClass self) => self -> String -> IO () -htmlButtonElementSetValue self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_button_element_set_value #} - (toHTMLButtonElement self) - valPtr +setValue :: + (MonadIO m, HTMLButtonElementClass self, GlibString string) => + self -> string -> m () +setValue self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_button_element_set_value #} + (toHTMLButtonElement self) + valPtr) -htmlButtonElementGetValue :: - (HTMLButtonElementClass self) => self -> IO String -htmlButtonElementGetValue self - = ({# call webkit_dom_html_button_element_get_value #} - (toHTMLButtonElement self)) - >>= - readUTFString +getValue :: + (MonadIO m, HTMLButtonElementClass self, GlibString string) => + self -> m string +getValue self + = liftIO + (({# call webkit_dom_html_button_element_get_value #} + (toHTMLButtonElement self)) + >>= + readUTFString) -htmlButtonElementGetWillValidate :: - (HTMLButtonElementClass self) => self -> IO Bool -htmlButtonElementGetWillValidate self - = toBool <$> - ({# call webkit_dom_html_button_element_get_will_validate #} - (toHTMLButtonElement self)) +getWillValidate :: + (MonadIO m, HTMLButtonElementClass self) => self -> m Bool +getWillValidate self + = liftIO + (toBool <$> + ({# call webkit_dom_html_button_element_get_will_validate #} + (toHTMLButtonElement self))) -htmlButtonElementGetValidity :: - (HTMLButtonElementClass self) => self -> IO (Maybe ValidityState) -htmlButtonElementGetValidity self - = maybeNull (makeNewGObject mkValidityState) - ({# call webkit_dom_html_button_element_get_validity #} - (toHTMLButtonElement self)) +getValidity :: + (MonadIO m, HTMLButtonElementClass self) => + self -> m (Maybe ValidityState) +getValidity self + = liftIO + (maybeNull (makeNewGObject mkValidityState) + ({# call webkit_dom_html_button_element_get_validity #} + (toHTMLButtonElement self))) -htmlButtonElementGetValidationMessage :: - (HTMLButtonElementClass self) => self -> IO String -htmlButtonElementGetValidationMessage self - = ({# call webkit_dom_html_button_element_get_validation_message #} - (toHTMLButtonElement self)) - >>= - readUTFString +getValidationMessage :: + (MonadIO m, HTMLButtonElementClass self, GlibString string) => + self -> m string +getValidationMessage self + = liftIO + (({# call webkit_dom_html_button_element_get_validation_message #} + (toHTMLButtonElement self)) + >>= + readUTFString) -htmlButtonElementGetLabels :: - (HTMLButtonElementClass self) => self -> IO (Maybe NodeList) -htmlButtonElementGetLabels self - = maybeNull (makeNewGObject mkNodeList) - ({# call webkit_dom_html_button_element_get_labels #} - (toHTMLButtonElement self)) +getLabels :: + (MonadIO m, HTMLButtonElementClass self) => + self -> m (Maybe NodeList) +getLabels self + = liftIO + (maybeNull (makeNewGObject mkNodeList) + ({# call webkit_dom_html_button_element_get_labels #} + (toHTMLButtonElement self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLCanvasElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLCanvasElement.chs --- a/Graphics/UI/Gtk/WebKit/DOM/HTMLCanvasElement.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLCanvasElement.chs @@ -1,40 +1,57 @@ -module Graphics.UI.Gtk.WebKit.DOM.HTMLCanvasElement - (htmlCanvasElementSetWidth, htmlCanvasElementGetWidth, - htmlCanvasElementSetHeight, htmlCanvasElementGetHeight, - HTMLCanvasElement, HTMLCanvasElementClass, castToHTMLCanvasElement, - gTypeHTMLCanvasElement, toHTMLCanvasElement) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.HTMLCanvasElement( +setWidth, +getWidth, +setHeight, +getHeight, +HTMLCanvasElement, +castToHTMLCanvasElement, +gTypeHTMLCanvasElement, +HTMLCanvasElementClass, +toHTMLCanvasElement, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -htmlCanvasElementSetWidth :: - (HTMLCanvasElementClass self) => self -> Int -> IO () -htmlCanvasElementSetWidth self val - = {# call webkit_dom_html_canvas_element_set_width #} - (toHTMLCanvasElement self) - (fromIntegral val) +setWidth :: + (MonadIO m, HTMLCanvasElementClass self) => self -> Int -> m () +setWidth self val + = liftIO + ({# call webkit_dom_html_canvas_element_set_width #} + (toHTMLCanvasElement self) + (fromIntegral val)) -htmlCanvasElementGetWidth :: - (HTMLCanvasElementClass self) => self -> IO Int -htmlCanvasElementGetWidth self - = fromIntegral <$> - ({# call webkit_dom_html_canvas_element_get_width #} - (toHTMLCanvasElement self)) +getWidth :: + (MonadIO m, HTMLCanvasElementClass self) => self -> m Int +getWidth self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_canvas_element_get_width #} + (toHTMLCanvasElement self))) -htmlCanvasElementSetHeight :: - (HTMLCanvasElementClass self) => self -> Int -> IO () -htmlCanvasElementSetHeight self val - = {# call webkit_dom_html_canvas_element_set_height #} - (toHTMLCanvasElement self) - (fromIntegral val) +setHeight :: + (MonadIO m, HTMLCanvasElementClass self) => self -> Int -> m () +setHeight self val + = liftIO + ({# call webkit_dom_html_canvas_element_set_height #} + (toHTMLCanvasElement self) + (fromIntegral val)) -htmlCanvasElementGetHeight :: - (HTMLCanvasElementClass self) => self -> IO Int -htmlCanvasElementGetHeight self - = fromIntegral <$> - ({# call webkit_dom_html_canvas_element_get_height #} - (toHTMLCanvasElement self)) +getHeight :: + (MonadIO m, HTMLCanvasElementClass self) => self -> m Int +getHeight self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_canvas_element_get_height #} + (toHTMLCanvasElement self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLCollection.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLCollection.chs --- a/Graphics/UI/Gtk/WebKit/DOM/HTMLCollection.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLCollection.chs @@ -1,40 +1,53 @@ -module Graphics.UI.Gtk.WebKit.DOM.HTMLCollection - (htmlCollectionItem, -#if WEBKIT_CHECK_VERSION(2,2,2) - htmlCollectionNamedItem, -#endif - htmlCollectionGetLength, HTMLCollection, HTMLCollectionClass, - castToHTMLCollection, gTypeHTMLCollection, toHTMLCollection) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.HTMLCollection( +item, +namedItem, +getLength, +HTMLCollection, +castToHTMLCollection, +gTypeHTMLCollection, +HTMLCollectionClass, +toHTMLCollection, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -htmlCollectionItem :: - (HTMLCollectionClass self) => self -> Word -> IO (Maybe Node) -htmlCollectionItem self index - = maybeNull (makeNewGObject mkNode) - ({# call webkit_dom_html_collection_item #} (toHTMLCollection self) - (fromIntegral index)) +item :: + (MonadIO m, HTMLCollectionClass self) => + self -> Word -> m (Maybe Node) +item self index + = liftIO + (maybeNull (makeNewGObject mkNode) + ({# call webkit_dom_html_collection_item #} (toHTMLCollection self) + (fromIntegral index))) -#if WEBKIT_CHECK_VERSION(2,2,2) -htmlCollectionNamedItem :: - (HTMLCollectionClass self) => self -> String -> IO (Maybe Node) -htmlCollectionNamedItem self name - = maybeNull (makeNewGObject mkNode) - (withUTFString name $ - \ namePtr -> - {# call webkit_dom_html_collection_named_item #} - (toHTMLCollection self) - namePtr) -#endif - -htmlCollectionGetLength :: - (HTMLCollectionClass self) => self -> IO Word -htmlCollectionGetLength self - = fromIntegral <$> - ({# call webkit_dom_html_collection_get_length #} - (toHTMLCollection self)) +namedItem :: + (MonadIO m, HTMLCollectionClass self, GlibString string) => + self -> string -> m (Maybe Node) +namedItem self name + = liftIO + (maybeNull (makeNewGObject mkNode) + (withUTFString name $ + \ namePtr -> + {# call webkit_dom_html_collection_named_item #} + (toHTMLCollection self) + namePtr)) + +getLength :: + (MonadIO m, HTMLCollectionClass self) => self -> m Word +getLength self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_collection_get_length #} + (toHTMLCollection self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLDListElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLDListElement.chs --- a/Graphics/UI/Gtk/WebKit/DOM/HTMLDListElement.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLDListElement.chs @@ -1,25 +1,39 @@ -module Graphics.UI.Gtk.WebKit.DOM.HTMLDListElement - (htmldListElementSetCompact, htmldListElementGetCompact, - HTMLDListElement, HTMLDListElementClass, castToHTMLDListElement, - gTypeHTMLDListElement, toHTMLDListElement) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.HTMLDListElement( +setCompact, +getCompact, +HTMLDListElement, +castToHTMLDListElement, +gTypeHTMLDListElement, +HTMLDListElementClass, +toHTMLDListElement, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -htmldListElementSetCompact :: - (HTMLDListElementClass self) => self -> Bool -> IO () -htmldListElementSetCompact self val - = {# call webkit_dom_htmld_list_element_set_compact #} - (toHTMLDListElement self) - (fromBool val) +setCompact :: + (MonadIO m, HTMLDListElementClass self) => self -> Bool -> m () +setCompact self val + = liftIO + ({# call webkit_dom_htmld_list_element_set_compact #} + (toHTMLDListElement self) + (fromBool val)) -htmldListElementGetCompact :: - (HTMLDListElementClass self) => self -> IO Bool -htmldListElementGetCompact self - = toBool <$> - ({# call webkit_dom_htmld_list_element_get_compact #} - (toHTMLDListElement self)) +getCompact :: + (MonadIO m, HTMLDListElementClass self) => self -> m Bool +getCompact self + = liftIO + (toBool <$> + ({# call webkit_dom_htmld_list_element_get_compact #} + (toHTMLDListElement self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLDetailsElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLDetailsElement.chs --- a/Graphics/UI/Gtk/WebKit/DOM/HTMLDetailsElement.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLDetailsElement.chs @@ -1,26 +1,39 @@ -module Graphics.UI.Gtk.WebKit.DOM.HTMLDetailsElement - (htmlDetailsElementSetOpen, htmlDetailsElementGetOpen, - HTMLDetailsElement, HTMLDetailsElementClass, - castToHTMLDetailsElement, gTypeHTMLDetailsElement, - toHTMLDetailsElement) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.HTMLDetailsElement( +setOpen, +getOpen, +HTMLDetailsElement, +castToHTMLDetailsElement, +gTypeHTMLDetailsElement, +HTMLDetailsElementClass, +toHTMLDetailsElement, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -htmlDetailsElementSetOpen :: - (HTMLDetailsElementClass self) => self -> Bool -> IO () -htmlDetailsElementSetOpen self val - = {# call webkit_dom_html_details_element_set_open #} - (toHTMLDetailsElement self) - (fromBool val) +setOpen :: + (MonadIO m, HTMLDetailsElementClass self) => self -> Bool -> m () +setOpen self val + = liftIO + ({# call webkit_dom_html_details_element_set_open #} + (toHTMLDetailsElement self) + (fromBool val)) -htmlDetailsElementGetOpen :: - (HTMLDetailsElementClass self) => self -> IO Bool -htmlDetailsElementGetOpen self - = toBool <$> - ({# call webkit_dom_html_details_element_get_open #} - (toHTMLDetailsElement self)) +getOpen :: + (MonadIO m, HTMLDetailsElementClass self) => self -> m Bool +getOpen self + = liftIO + (toBool <$> + ({# call webkit_dom_html_details_element_get_open #} + (toHTMLDetailsElement self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLDirectoryElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLDirectoryElement.chs --- a/Graphics/UI/Gtk/WebKit/DOM/HTMLDirectoryElement.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLDirectoryElement.chs @@ -1,26 +1,39 @@ -module Graphics.UI.Gtk.WebKit.DOM.HTMLDirectoryElement - (htmlDirectoryElementSetCompact, htmlDirectoryElementGetCompact, - HTMLDirectoryElement, HTMLDirectoryElementClass, - castToHTMLDirectoryElement, gTypeHTMLDirectoryElement, - toHTMLDirectoryElement) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.HTMLDirectoryElement( +setCompact, +getCompact, +HTMLDirectoryElement, +castToHTMLDirectoryElement, +gTypeHTMLDirectoryElement, +HTMLDirectoryElementClass, +toHTMLDirectoryElement, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -htmlDirectoryElementSetCompact :: - (HTMLDirectoryElementClass self) => self -> Bool -> IO () -htmlDirectoryElementSetCompact self val - = {# call webkit_dom_html_directory_element_set_compact #} - (toHTMLDirectoryElement self) - (fromBool val) +setCompact :: + (MonadIO m, HTMLDirectoryElementClass self) => self -> Bool -> m () +setCompact self val + = liftIO + ({# call webkit_dom_html_directory_element_set_compact #} + (toHTMLDirectoryElement self) + (fromBool val)) -htmlDirectoryElementGetCompact :: - (HTMLDirectoryElementClass self) => self -> IO Bool -htmlDirectoryElementGetCompact self - = toBool <$> - ({# call webkit_dom_html_directory_element_get_compact #} - (toHTMLDirectoryElement self)) +getCompact :: + (MonadIO m, HTMLDirectoryElementClass self) => self -> m Bool +getCompact self + = liftIO + (toBool <$> + ({# call webkit_dom_html_directory_element_get_compact #} + (toHTMLDirectoryElement self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLDivElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLDivElement.chs --- a/Graphics/UI/Gtk/WebKit/DOM/HTMLDivElement.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLDivElement.chs @@ -1,28 +1,44 @@ -module Graphics.UI.Gtk.WebKit.DOM.HTMLDivElement - (htmlDivElementSetAlign, htmlDivElementGetAlign, HTMLDivElement, - HTMLDivElementClass, castToHTMLDivElement, gTypeHTMLDivElement, - toHTMLDivElement) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.HTMLDivElement( +setAlign, +getAlign, +HTMLDivElement, +castToHTMLDivElement, +gTypeHTMLDivElement, +HTMLDivElementClass, +toHTMLDivElement, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -htmlDivElementSetAlign :: - (HTMLDivElementClass self) => self -> String -> IO () -htmlDivElementSetAlign self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_div_element_set_align #} - (toHTMLDivElement self) - valPtr +setAlign :: + (MonadIO m, HTMLDivElementClass self, GlibString string) => + self -> string -> m () +setAlign self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_div_element_set_align #} + (toHTMLDivElement self) + valPtr) -htmlDivElementGetAlign :: - (HTMLDivElementClass self) => self -> IO String -htmlDivElementGetAlign self - = ({# call webkit_dom_html_div_element_get_align #} - (toHTMLDivElement self)) - >>= - readUTFString +getAlign :: + (MonadIO m, HTMLDivElementClass self, GlibString string) => + self -> m string +getAlign self + = liftIO + (({# call webkit_dom_html_div_element_get_align #} + (toHTMLDivElement self)) + >>= + readUTFString) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLDocument.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLDocument.chs --- a/Graphics/UI/Gtk/WebKit/DOM/HTMLDocument.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLDocument.chs @@ -1,213 +1,266 @@ -module Graphics.UI.Gtk.WebKit.DOM.HTMLDocument - (htmlDocumentClose, htmlDocumentClear, htmlDocumentCaptureEvents, - htmlDocumentReleaseEvents, htmlDocumentHasFocus, - htmlDocumentGetEmbeds, htmlDocumentGetPlugins, - htmlDocumentGetScripts, htmlDocumentGetWidth, - htmlDocumentGetHeight, htmlDocumentSetDir, htmlDocumentGetDir, - htmlDocumentSetDesignMode, htmlDocumentGetDesignMode, - htmlDocumentGetCompatMode, htmlDocumentGetActiveElement, - htmlDocumentSetBgColor, htmlDocumentGetBgColor, - htmlDocumentSetFgColor, htmlDocumentGetFgColor, - htmlDocumentSetAlinkColor, htmlDocumentGetAlinkColor, - htmlDocumentSetLinkColor, htmlDocumentGetLinkColor, - htmlDocumentSetVlinkColor, htmlDocumentGetVlinkColor, HTMLDocument, - HTMLDocumentClass, castToHTMLDocument, gTypeHTMLDocument, - toHTMLDocument) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.HTMLDocument( +close, +clear, +captureEvents, +releaseEvents, +getEmbeds, +getPlugins, +getScripts, +getWidth, +getHeight, +setDir, +getDir, +setDesignMode, +getDesignMode, +getCompatMode, +setBgColor, +getBgColor, +setFgColor, +getFgColor, +setAlinkColor, +getAlinkColor, +setLinkColor, +getLinkColor, +setVlinkColor, +getVlinkColor, +HTMLDocument, +castToHTMLDocument, +gTypeHTMLDocument, +HTMLDocumentClass, +toHTMLDocument, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM - -htmlDocumentClose :: (HTMLDocumentClass self) => self -> IO () -htmlDocumentClose self - = {# call webkit_dom_html_document_close #} (toHTMLDocument self) - -htmlDocumentClear :: (HTMLDocumentClass self) => self -> IO () -htmlDocumentClear self - = {# call webkit_dom_html_document_clear #} (toHTMLDocument self) +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -htmlDocumentCaptureEvents :: - (HTMLDocumentClass self) => self -> IO () -htmlDocumentCaptureEvents self - = {# call webkit_dom_html_document_capture_events #} - (toHTMLDocument self) +close :: (MonadIO m, HTMLDocumentClass self) => self -> m () +close self + = liftIO + ({# call webkit_dom_html_document_close #} (toHTMLDocument self)) -htmlDocumentReleaseEvents :: - (HTMLDocumentClass self) => self -> IO () -htmlDocumentReleaseEvents self - = {# call webkit_dom_html_document_release_events #} - (toHTMLDocument self) +clear :: (MonadIO m, HTMLDocumentClass self) => self -> m () +clear self + = liftIO + ({# call webkit_dom_html_document_clear #} (toHTMLDocument self)) -htmlDocumentHasFocus :: (HTMLDocumentClass self) => self -> IO Bool -htmlDocumentHasFocus self - = toBool <$> - ({# call webkit_dom_html_document_has_focus #} +captureEvents :: + (MonadIO m, HTMLDocumentClass self) => self -> m () +captureEvents self + = liftIO + ({# call webkit_dom_html_document_capture_events #} (toHTMLDocument self)) -htmlDocumentGetEmbeds :: - (HTMLDocumentClass self) => self -> IO (Maybe HTMLCollection) -htmlDocumentGetEmbeds self - = maybeNull (makeNewGObject mkHTMLCollection) - ({# call webkit_dom_html_document_get_embeds #} +releaseEvents :: + (MonadIO m, HTMLDocumentClass self) => self -> m () +releaseEvents self + = liftIO + ({# call webkit_dom_html_document_release_events #} (toHTMLDocument self)) -htmlDocumentGetPlugins :: - (HTMLDocumentClass self) => self -> IO (Maybe HTMLCollection) -htmlDocumentGetPlugins self - = maybeNull (makeNewGObject mkHTMLCollection) - ({# call webkit_dom_html_document_get_plugins #} - (toHTMLDocument self)) +getEmbeds :: + (MonadIO m, HTMLDocumentClass self) => + self -> m (Maybe HTMLCollection) +getEmbeds self + = liftIO + (maybeNull (makeNewGObject mkHTMLCollection) + ({# call webkit_dom_html_document_get_embeds #} + (toHTMLDocument self))) -htmlDocumentGetScripts :: - (HTMLDocumentClass self) => self -> IO (Maybe HTMLCollection) -htmlDocumentGetScripts self - = maybeNull (makeNewGObject mkHTMLCollection) - ({# call webkit_dom_html_document_get_scripts #} - (toHTMLDocument self)) +getPlugins :: + (MonadIO m, HTMLDocumentClass self) => + self -> m (Maybe HTMLCollection) +getPlugins self + = liftIO + (maybeNull (makeNewGObject mkHTMLCollection) + ({# call webkit_dom_html_document_get_plugins #} + (toHTMLDocument self))) -htmlDocumentGetWidth :: (HTMLDocumentClass self) => self -> IO Int -htmlDocumentGetWidth self - = fromIntegral <$> - ({# call webkit_dom_html_document_get_width #} - (toHTMLDocument self)) +getScripts :: + (MonadIO m, HTMLDocumentClass self) => + self -> m (Maybe HTMLCollection) +getScripts self + = liftIO + (maybeNull (makeNewGObject mkHTMLCollection) + ({# call webkit_dom_html_document_get_scripts #} + (toHTMLDocument self))) -htmlDocumentGetHeight :: (HTMLDocumentClass self) => self -> IO Int -htmlDocumentGetHeight self - = fromIntegral <$> - ({# call webkit_dom_html_document_get_height #} - (toHTMLDocument self)) +getWidth :: (MonadIO m, HTMLDocumentClass self) => self -> m Int +getWidth self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_document_get_width #} + (toHTMLDocument self))) -htmlDocumentSetDir :: - (HTMLDocumentClass self) => self -> String -> IO () -htmlDocumentSetDir self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_document_set_dir #} (toHTMLDocument self) - valPtr +getHeight :: (MonadIO m, HTMLDocumentClass self) => self -> m Int +getHeight self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_document_get_height #} + (toHTMLDocument self))) -htmlDocumentGetDir :: (HTMLDocumentClass self) => self -> IO String -htmlDocumentGetDir self - = ({# call webkit_dom_html_document_get_dir #} - (toHTMLDocument self)) - >>= - readUTFString +setDir :: + (MonadIO m, HTMLDocumentClass self, GlibString string) => + self -> (Maybe string) -> m () +setDir self val + = liftIO + (maybeWith withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_document_set_dir #} (toHTMLDocument self) + valPtr) -htmlDocumentSetDesignMode :: - (HTMLDocumentClass self) => self -> String -> IO () -htmlDocumentSetDesignMode self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_document_set_design_mode #} - (toHTMLDocument self) - valPtr +getDir :: + (MonadIO m, HTMLDocumentClass self, GlibString string) => + self -> m (Maybe string) +getDir self + = liftIO + (({# call webkit_dom_html_document_get_dir #} + (toHTMLDocument self)) + >>= + maybePeek readUTFString) -htmlDocumentGetDesignMode :: - (HTMLDocumentClass self) => self -> IO String -htmlDocumentGetDesignMode self - = ({# call webkit_dom_html_document_get_design_mode #} - (toHTMLDocument self)) - >>= - readUTFString +setDesignMode :: + (MonadIO m, HTMLDocumentClass self, GlibString string) => + self -> (Maybe string) -> m () +setDesignMode self val + = liftIO + (maybeWith withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_document_set_design_mode #} + (toHTMLDocument self) + valPtr) -htmlDocumentGetCompatMode :: - (HTMLDocumentClass self) => self -> IO String -htmlDocumentGetCompatMode self - = ({# call webkit_dom_html_document_get_compat_mode #} - (toHTMLDocument self)) - >>= - readUTFString +getDesignMode :: + (MonadIO m, HTMLDocumentClass self, GlibString string) => + self -> m (Maybe string) +getDesignMode self + = liftIO + (({# call webkit_dom_html_document_get_design_mode #} + (toHTMLDocument self)) + >>= + maybePeek readUTFString) -htmlDocumentGetActiveElement :: - (HTMLDocumentClass self) => self -> IO (Maybe Element) -htmlDocumentGetActiveElement self - = maybeNull (makeNewGObject mkElement) - ({# call webkit_dom_html_document_get_active_element #} - (toHTMLDocument self)) +getCompatMode :: + (MonadIO m, HTMLDocumentClass self, GlibString string) => + self -> m string +getCompatMode self + = liftIO + (({# call webkit_dom_html_document_get_compat_mode #} + (toHTMLDocument self)) + >>= + readUTFString) -htmlDocumentSetBgColor :: - (HTMLDocumentClass self) => self -> String -> IO () -htmlDocumentSetBgColor self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_document_set_bg_color #} - (toHTMLDocument self) - valPtr +setBgColor :: + (MonadIO m, HTMLDocumentClass self, GlibString string) => + self -> (Maybe string) -> m () +setBgColor self val + = liftIO + (maybeWith withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_document_set_bg_color #} + (toHTMLDocument self) + valPtr) -htmlDocumentGetBgColor :: - (HTMLDocumentClass self) => self -> IO String -htmlDocumentGetBgColor self - = ({# call webkit_dom_html_document_get_bg_color #} - (toHTMLDocument self)) - >>= - readUTFString +getBgColor :: + (MonadIO m, HTMLDocumentClass self, GlibString string) => + self -> m (Maybe string) +getBgColor self + = liftIO + (({# call webkit_dom_html_document_get_bg_color #} + (toHTMLDocument self)) + >>= + maybePeek readUTFString) -htmlDocumentSetFgColor :: - (HTMLDocumentClass self) => self -> String -> IO () -htmlDocumentSetFgColor self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_document_set_fg_color #} - (toHTMLDocument self) - valPtr +setFgColor :: + (MonadIO m, HTMLDocumentClass self, GlibString string) => + self -> (Maybe string) -> m () +setFgColor self val + = liftIO + (maybeWith withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_document_set_fg_color #} + (toHTMLDocument self) + valPtr) -htmlDocumentGetFgColor :: - (HTMLDocumentClass self) => self -> IO String -htmlDocumentGetFgColor self - = ({# call webkit_dom_html_document_get_fg_color #} - (toHTMLDocument self)) - >>= - readUTFString +getFgColor :: + (MonadIO m, HTMLDocumentClass self, GlibString string) => + self -> m (Maybe string) +getFgColor self + = liftIO + (({# call webkit_dom_html_document_get_fg_color #} + (toHTMLDocument self)) + >>= + maybePeek readUTFString) -htmlDocumentSetAlinkColor :: - (HTMLDocumentClass self) => self -> String -> IO () -htmlDocumentSetAlinkColor self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_document_set_alink_color #} - (toHTMLDocument self) - valPtr +setAlinkColor :: + (MonadIO m, HTMLDocumentClass self, GlibString string) => + self -> (Maybe string) -> m () +setAlinkColor self val + = liftIO + (maybeWith withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_document_set_alink_color #} + (toHTMLDocument self) + valPtr) -htmlDocumentGetAlinkColor :: - (HTMLDocumentClass self) => self -> IO String -htmlDocumentGetAlinkColor self - = ({# call webkit_dom_html_document_get_alink_color #} - (toHTMLDocument self)) - >>= - readUTFString +getAlinkColor :: + (MonadIO m, HTMLDocumentClass self, GlibString string) => + self -> m (Maybe string) +getAlinkColor self + = liftIO + (({# call webkit_dom_html_document_get_alink_color #} + (toHTMLDocument self)) + >>= + maybePeek readUTFString) -htmlDocumentSetLinkColor :: - (HTMLDocumentClass self) => self -> String -> IO () -htmlDocumentSetLinkColor self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_document_set_link_color #} - (toHTMLDocument self) - valPtr +setLinkColor :: + (MonadIO m, HTMLDocumentClass self, GlibString string) => + self -> (Maybe string) -> m () +setLinkColor self val + = liftIO + (maybeWith withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_document_set_link_color #} + (toHTMLDocument self) + valPtr) -htmlDocumentGetLinkColor :: - (HTMLDocumentClass self) => self -> IO String -htmlDocumentGetLinkColor self - = ({# call webkit_dom_html_document_get_link_color #} - (toHTMLDocument self)) - >>= - readUTFString +getLinkColor :: + (MonadIO m, HTMLDocumentClass self, GlibString string) => + self -> m (Maybe string) +getLinkColor self + = liftIO + (({# call webkit_dom_html_document_get_link_color #} + (toHTMLDocument self)) + >>= + maybePeek readUTFString) -htmlDocumentSetVlinkColor :: - (HTMLDocumentClass self) => self -> String -> IO () -htmlDocumentSetVlinkColor self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_document_set_vlink_color #} - (toHTMLDocument self) - valPtr +setVlinkColor :: + (MonadIO m, HTMLDocumentClass self, GlibString string) => + self -> (Maybe string) -> m () +setVlinkColor self val + = liftIO + (maybeWith withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_document_set_vlink_color #} + (toHTMLDocument self) + valPtr) -htmlDocumentGetVlinkColor :: - (HTMLDocumentClass self) => self -> IO String -htmlDocumentGetVlinkColor self - = ({# call webkit_dom_html_document_get_vlink_color #} - (toHTMLDocument self)) - >>= - readUTFString +getVlinkColor :: + (MonadIO m, HTMLDocumentClass self, GlibString string) => + self -> m (Maybe string) +getVlinkColor self + = liftIO + (({# call webkit_dom_html_document_get_vlink_color #} + (toHTMLDocument self)) + >>= + maybePeek readUTFString) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLElement.chs --- a/Graphics/UI/Gtk/WebKit/DOM/HTMLElement.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLElement.chs @@ -1,336 +1,375 @@ -module Graphics.UI.Gtk.WebKit.DOM.HTMLElement - (htmlElementInsertAdjacentElement, htmlElementInsertAdjacentHTML, - htmlElementInsertAdjacentText, htmlElementClick, - htmlElementSetTitle, htmlElementGetTitle, htmlElementSetLang, - htmlElementGetLang, htmlElementSetTranslate, - htmlElementGetTranslate, htmlElementSetDir, htmlElementGetDir, - htmlElementSetTabIndex, htmlElementGetTabIndex, - htmlElementSetDraggable, htmlElementGetDraggable, - htmlElementSetWebkitdropzone, htmlElementGetWebkitdropzone, - htmlElementSetHidden, htmlElementGetHidden, - htmlElementSetAccessKey, htmlElementGetAccessKey, - htmlElementSetInnerHTML, htmlElementGetInnerHTML, - htmlElementSetInnerText, htmlElementGetInnerText, - htmlElementSetOuterHTML, htmlElementGetOuterHTML, - htmlElementSetOuterText, htmlElementGetOuterText, - htmlElementGetChildren, htmlElementSetContentEditable, - htmlElementGetContentEditable, htmlElementGetIsContentEditable, - htmlElementSetSpellcheck, htmlElementGetSpellcheck, HTMLElement, - HTMLElementClass, castToHTMLElement, gTypeHTMLElement, - toHTMLElement) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.HTMLElement( +insertAdjacentElement, +insertAdjacentHTML, +insertAdjacentText, +click, +setTitle, +getTitle, +setLang, +getLang, +setTranslate, +getTranslate, +setDir, +getDir, +setTabIndex, +getTabIndex, +setDraggable, +getDraggable, +setWebkitdropzone, +getWebkitdropzone, +setHidden, +getHidden, +setAccessKey, +getAccessKey, +setInnerText, +getInnerText, +setOuterText, +getOuterText, +getChildren, +setContentEditable, +getContentEditable, +getIsContentEditable, +setSpellcheck, +getSpellcheck, +HTMLElement, +castToHTMLElement, +gTypeHTMLElement, +HTMLElementClass, +toHTMLElement, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -htmlElementInsertAdjacentElement :: - (HTMLElementClass self, ElementClass element) => - self -> String -> Maybe element -> IO (Maybe Element) -htmlElementInsertAdjacentElement self where' element - = maybeNull (makeNewGObject mkElement) +insertAdjacentElement :: + (MonadIO m, HTMLElementClass self, ElementClass element, + GlibString string) => + self -> string -> Maybe element -> m (Maybe Element) +insertAdjacentElement self where' element + = liftIO + (maybeNull (makeNewGObject mkElement) + (propagateGError $ + \ errorPtr_ -> + withUTFString where' $ + \ wherePtr -> + {# call webkit_dom_html_element_insert_adjacent_element #} + (toHTMLElement self) + wherePtr + (maybe (Element nullForeignPtr) toElement element) + errorPtr_)) + +insertAdjacentHTML :: + (MonadIO m, HTMLElementClass self, GlibString string) => + self -> string -> string -> m () +insertAdjacentHTML self where' html + = liftIO (propagateGError $ \ errorPtr_ -> - withUTFString where' $ - \ wherePtr -> - {# call webkit_dom_html_element_insert_adjacent_element #} - (toHTMLElement self) - wherePtr - (maybe (Element nullForeignPtr) toElement element) + withUTFString html $ + \ htmlPtr -> + withUTFString where' $ + \ wherePtr -> + {# call webkit_dom_html_element_insert_adjacent_html #} + (toHTMLElement self) + wherePtr + htmlPtr errorPtr_) -htmlElementInsertAdjacentHTML :: - (HTMLElementClass self) => self -> String -> String -> IO () -htmlElementInsertAdjacentHTML self where' html - = propagateGError $ - \ errorPtr_ -> - withUTFString html $ - \ htmlPtr -> - withUTFString where' $ - \ wherePtr -> - {# call webkit_dom_html_element_insert_adjacent_html #} - (toHTMLElement self) - wherePtr - htmlPtr - errorPtr_ - -htmlElementInsertAdjacentText :: - (HTMLElementClass self) => self -> String -> String -> IO () -htmlElementInsertAdjacentText self where' text - = propagateGError $ - \ errorPtr_ -> - withUTFString text $ - \ textPtr -> - withUTFString where' $ - \ wherePtr -> - {# call webkit_dom_html_element_insert_adjacent_text #} - (toHTMLElement self) - wherePtr - textPtr - errorPtr_ - -htmlElementClick :: (HTMLElementClass self) => self -> IO () -htmlElementClick self - = {# call webkit_dom_html_element_click #} (toHTMLElement self) - -htmlElementSetTitle :: - (HTMLElementClass self) => self -> String -> IO () -htmlElementSetTitle self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_element_set_title #} (toHTMLElement self) - valPtr - -htmlElementGetTitle :: (HTMLElementClass self) => self -> IO String -htmlElementGetTitle self - = ({# call webkit_dom_html_element_get_title #} - (toHTMLElement self)) - >>= - readUTFString - -htmlElementSetLang :: - (HTMLElementClass self) => self -> String -> IO () -htmlElementSetLang self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_element_set_lang #} (toHTMLElement self) - valPtr +insertAdjacentText :: + (MonadIO m, HTMLElementClass self, GlibString string) => + self -> string -> string -> m () +insertAdjacentText self where' text + = liftIO + (propagateGError $ + \ errorPtr_ -> + withUTFString text $ + \ textPtr -> + withUTFString where' $ + \ wherePtr -> + {# call webkit_dom_html_element_insert_adjacent_text #} + (toHTMLElement self) + wherePtr + textPtr + errorPtr_) -htmlElementGetLang :: (HTMLElementClass self) => self -> IO String -htmlElementGetLang self - = ({# call webkit_dom_html_element_get_lang #} - (toHTMLElement self)) - >>= - readUTFString +click :: (MonadIO m, HTMLElementClass self) => self -> m () +click self + = liftIO + ({# call webkit_dom_html_element_click #} (toHTMLElement self)) -htmlElementSetTranslate :: - (HTMLElementClass self) => self -> Bool -> IO () -htmlElementSetTranslate self val - = {# call webkit_dom_html_element_set_translate #} - (toHTMLElement self) - (fromBool val) +setTitle :: + (MonadIO m, HTMLElementClass self, GlibString string) => + self -> string -> m () +setTitle self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_element_set_title #} (toHTMLElement self) + valPtr) -htmlElementGetTranslate :: - (HTMLElementClass self) => self -> IO Bool -htmlElementGetTranslate self - = toBool <$> - ({# call webkit_dom_html_element_get_translate #} - (toHTMLElement self)) +getTitle :: + (MonadIO m, HTMLElementClass self, GlibString string) => + self -> m string +getTitle self + = liftIO + (({# call webkit_dom_html_element_get_title #} + (toHTMLElement self)) + >>= + readUTFString) -htmlElementSetDir :: - (HTMLElementClass self) => self -> String -> IO () -htmlElementSetDir self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_element_set_dir #} (toHTMLElement self) - valPtr +setLang :: + (MonadIO m, HTMLElementClass self, GlibString string) => + self -> string -> m () +setLang self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_element_set_lang #} (toHTMLElement self) + valPtr) -htmlElementGetDir :: (HTMLElementClass self) => self -> IO String -htmlElementGetDir self - = ({# call webkit_dom_html_element_get_dir #} (toHTMLElement self)) - >>= - readUTFString +getLang :: + (MonadIO m, HTMLElementClass self, GlibString string) => + self -> m string +getLang self + = liftIO + (({# call webkit_dom_html_element_get_lang #} (toHTMLElement self)) + >>= + readUTFString) -htmlElementSetTabIndex :: - (HTMLElementClass self) => self -> Int -> IO () -htmlElementSetTabIndex self val - = {# call webkit_dom_html_element_set_tab_index #} - (toHTMLElement self) - (fromIntegral val) +setTranslate :: + (MonadIO m, HTMLElementClass self) => self -> Bool -> m () +setTranslate self val + = liftIO + ({# call webkit_dom_html_element_set_translate #} + (toHTMLElement self) + (fromBool val)) -htmlElementGetTabIndex :: (HTMLElementClass self) => self -> IO Int -htmlElementGetTabIndex self - = fromIntegral <$> - ({# call webkit_dom_html_element_get_tab_index #} - (toHTMLElement self)) +getTranslate :: + (MonadIO m, HTMLElementClass self) => self -> m Bool +getTranslate self + = liftIO + (toBool <$> + ({# call webkit_dom_html_element_get_translate #} + (toHTMLElement self))) -htmlElementSetDraggable :: - (HTMLElementClass self) => self -> Bool -> IO () -htmlElementSetDraggable self val - = {# call webkit_dom_html_element_set_draggable #} - (toHTMLElement self) - (fromBool val) +setDir :: + (MonadIO m, HTMLElementClass self, GlibString string) => + self -> string -> m () +setDir self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_element_set_dir #} (toHTMLElement self) + valPtr) -htmlElementGetDraggable :: - (HTMLElementClass self) => self -> IO Bool -htmlElementGetDraggable self - = toBool <$> - ({# call webkit_dom_html_element_get_draggable #} - (toHTMLElement self)) +getDir :: + (MonadIO m, HTMLElementClass self, GlibString string) => + self -> m string +getDir self + = liftIO + (({# call webkit_dom_html_element_get_dir #} (toHTMLElement self)) + >>= + readUTFString) -htmlElementSetWebkitdropzone :: - (HTMLElementClass self) => self -> String -> IO () -htmlElementSetWebkitdropzone self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_element_set_webkitdropzone #} - (toHTMLElement self) - valPtr +setTabIndex :: + (MonadIO m, HTMLElementClass self) => self -> Int -> m () +setTabIndex self val + = liftIO + ({# call webkit_dom_html_element_set_tab_index #} + (toHTMLElement self) + (fromIntegral val)) -htmlElementGetWebkitdropzone :: - (HTMLElementClass self) => self -> IO String -htmlElementGetWebkitdropzone self - = ({# call webkit_dom_html_element_get_webkitdropzone #} - (toHTMLElement self)) - >>= - readUTFString +getTabIndex :: (MonadIO m, HTMLElementClass self) => self -> m Int +getTabIndex self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_element_get_tab_index #} + (toHTMLElement self))) -htmlElementSetHidden :: - (HTMLElementClass self) => self -> Bool -> IO () -htmlElementSetHidden self val - = {# call webkit_dom_html_element_set_hidden #} - (toHTMLElement self) - (fromBool val) +setDraggable :: + (MonadIO m, HTMLElementClass self) => self -> Bool -> m () +setDraggable self val + = liftIO + ({# call webkit_dom_html_element_set_draggable #} + (toHTMLElement self) + (fromBool val)) -htmlElementGetHidden :: (HTMLElementClass self) => self -> IO Bool -htmlElementGetHidden self - = toBool <$> - ({# call webkit_dom_html_element_get_hidden #} - (toHTMLElement self)) +getDraggable :: + (MonadIO m, HTMLElementClass self) => self -> m Bool +getDraggable self + = liftIO + (toBool <$> + ({# call webkit_dom_html_element_get_draggable #} + (toHTMLElement self))) -htmlElementSetAccessKey :: - (HTMLElementClass self) => self -> String -> IO () -htmlElementSetAccessKey self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_element_set_access_key #} - (toHTMLElement self) - valPtr +setWebkitdropzone :: + (MonadIO m, HTMLElementClass self, GlibString string) => + self -> string -> m () +setWebkitdropzone self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_element_set_webkitdropzone #} + (toHTMLElement self) + valPtr) -htmlElementGetAccessKey :: - (HTMLElementClass self) => self -> IO String -htmlElementGetAccessKey self - = ({# call webkit_dom_html_element_get_access_key #} - (toHTMLElement self)) - >>= - readUTFString +getWebkitdropzone :: + (MonadIO m, HTMLElementClass self, GlibString string) => + self -> m string +getWebkitdropzone self + = liftIO + (({# call webkit_dom_html_element_get_webkitdropzone #} + (toHTMLElement self)) + >>= + readUTFString) -htmlElementSetInnerHTML :: - (HTMLElementClass self) => self -> String -> IO () -htmlElementSetInnerHTML self val - = propagateGError $ - \ errorPtr_ -> - withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_element_set_inner_html #} - (toHTMLElement self) - valPtr - errorPtr_ +setHidden :: + (MonadIO m, HTMLElementClass self) => self -> Bool -> m () +setHidden self val + = liftIO + ({# call webkit_dom_html_element_set_hidden #} (toHTMLElement self) + (fromBool val)) -htmlElementGetInnerHTML :: - (HTMLElementClass self) => self -> IO String -htmlElementGetInnerHTML self - = ({# call webkit_dom_html_element_get_inner_html #} - (toHTMLElement self)) - >>= - readUTFString +getHidden :: (MonadIO m, HTMLElementClass self) => self -> m Bool +getHidden self + = liftIO + (toBool <$> + ({# call webkit_dom_html_element_get_hidden #} + (toHTMLElement self))) -htmlElementSetInnerText :: - (HTMLElementClass self) => self -> String -> IO () -htmlElementSetInnerText self val - = propagateGError $ - \ errorPtr_ -> - withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_element_set_inner_text #} - (toHTMLElement self) - valPtr - errorPtr_ +setAccessKey :: + (MonadIO m, HTMLElementClass self, GlibString string) => + self -> string -> m () +setAccessKey self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_element_set_access_key #} + (toHTMLElement self) + valPtr) -htmlElementGetInnerText :: - (HTMLElementClass self) => self -> IO String -htmlElementGetInnerText self - = ({# call webkit_dom_html_element_get_inner_text #} - (toHTMLElement self)) - >>= - readUTFString +getAccessKey :: + (MonadIO m, HTMLElementClass self, GlibString string) => + self -> m string +getAccessKey self + = liftIO + (({# call webkit_dom_html_element_get_access_key #} + (toHTMLElement self)) + >>= + readUTFString) -htmlElementSetOuterHTML :: - (HTMLElementClass self) => self -> String -> IO () -htmlElementSetOuterHTML self val - = propagateGError $ - \ errorPtr_ -> - withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_element_set_outer_html #} - (toHTMLElement self) - valPtr - errorPtr_ +setInnerText :: + (MonadIO m, HTMLElementClass self, GlibString string) => + self -> (Maybe string) -> m () +setInnerText self val + = liftIO + (propagateGError $ + \ errorPtr_ -> + maybeWith withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_element_set_inner_text #} + (toHTMLElement self) + valPtr + errorPtr_) -htmlElementGetOuterHTML :: - (HTMLElementClass self) => self -> IO String -htmlElementGetOuterHTML self - = ({# call webkit_dom_html_element_get_outer_html #} - (toHTMLElement self)) - >>= - readUTFString +getInnerText :: + (MonadIO m, HTMLElementClass self, GlibString string) => + self -> m (Maybe string) +getInnerText self + = liftIO + (({# call webkit_dom_html_element_get_inner_text #} + (toHTMLElement self)) + >>= + maybePeek readUTFString) -htmlElementSetOuterText :: - (HTMLElementClass self) => self -> String -> IO () -htmlElementSetOuterText self val - = propagateGError $ - \ errorPtr_ -> - withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_element_set_outer_text #} - (toHTMLElement self) - valPtr - errorPtr_ +setOuterText :: + (MonadIO m, HTMLElementClass self, GlibString string) => + self -> (Maybe string) -> m () +setOuterText self val + = liftIO + (propagateGError $ + \ errorPtr_ -> + maybeWith withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_element_set_outer_text #} + (toHTMLElement self) + valPtr + errorPtr_) -htmlElementGetOuterText :: - (HTMLElementClass self) => self -> IO String -htmlElementGetOuterText self - = ({# call webkit_dom_html_element_get_outer_text #} - (toHTMLElement self)) - >>= - readUTFString +getOuterText :: + (MonadIO m, HTMLElementClass self, GlibString string) => + self -> m (Maybe string) +getOuterText self + = liftIO + (({# call webkit_dom_html_element_get_outer_text #} + (toHTMLElement self)) + >>= + maybePeek readUTFString) -htmlElementGetChildren :: - (HTMLElementClass self) => self -> IO (Maybe HTMLCollection) -htmlElementGetChildren self - = maybeNull (makeNewGObject mkHTMLCollection) - ({# call webkit_dom_html_element_get_children #} - (toHTMLElement self)) +getChildren :: + (MonadIO m, HTMLElementClass self) => + self -> m (Maybe HTMLCollection) +getChildren self + = liftIO + (maybeNull (makeNewGObject mkHTMLCollection) + ({# call webkit_dom_html_element_get_children #} + (toHTMLElement self))) -htmlElementSetContentEditable :: - (HTMLElementClass self) => self -> String -> IO () -htmlElementSetContentEditable self val - = propagateGError $ - \ errorPtr_ -> - withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_element_set_content_editable #} - (toHTMLElement self) - valPtr - errorPtr_ +setContentEditable :: + (MonadIO m, HTMLElementClass self, GlibString string) => + self -> (Maybe string) -> m () +setContentEditable self val + = liftIO + (propagateGError $ + \ errorPtr_ -> + maybeWith withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_element_set_content_editable #} + (toHTMLElement self) + valPtr + errorPtr_) -htmlElementGetContentEditable :: - (HTMLElementClass self) => self -> IO String -htmlElementGetContentEditable self - = ({# call webkit_dom_html_element_get_content_editable #} - (toHTMLElement self)) - >>= - readUTFString +getContentEditable :: + (MonadIO m, HTMLElementClass self, GlibString string) => + self -> m (Maybe string) +getContentEditable self + = liftIO + (({# call webkit_dom_html_element_get_content_editable #} + (toHTMLElement self)) + >>= + maybePeek readUTFString) -htmlElementGetIsContentEditable :: - (HTMLElementClass self) => self -> IO Bool -htmlElementGetIsContentEditable self - = toBool <$> - ({# call webkit_dom_html_element_get_is_content_editable #} - (toHTMLElement self)) +getIsContentEditable :: + (MonadIO m, HTMLElementClass self) => self -> m Bool +getIsContentEditable self + = liftIO + (toBool <$> + ({# call webkit_dom_html_element_get_is_content_editable #} + (toHTMLElement self))) -htmlElementSetSpellcheck :: - (HTMLElementClass self) => self -> Bool -> IO () -htmlElementSetSpellcheck self val - = {# call webkit_dom_html_element_set_spellcheck #} - (toHTMLElement self) - (fromBool val) +setSpellcheck :: + (MonadIO m, HTMLElementClass self) => self -> Bool -> m () +setSpellcheck self val + = liftIO + ({# call webkit_dom_html_element_set_spellcheck #} + (toHTMLElement self) + (fromBool val)) -htmlElementGetSpellcheck :: - (HTMLElementClass self) => self -> IO Bool -htmlElementGetSpellcheck self - = toBool <$> - ({# call webkit_dom_html_element_get_spellcheck #} - (toHTMLElement self)) +getSpellcheck :: + (MonadIO m, HTMLElementClass self) => self -> m Bool +getSpellcheck self + = liftIO + (toBool <$> + ({# call webkit_dom_html_element_get_spellcheck #} + (toHTMLElement self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLEmbedElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLEmbedElement.chs --- a/Graphics/UI/Gtk/WebKit/DOM/HTMLEmbedElement.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLEmbedElement.chs @@ -1,94 +1,126 @@ -module Graphics.UI.Gtk.WebKit.DOM.HTMLEmbedElement - (htmlEmbedElementSetAlign, htmlEmbedElementGetAlign, - htmlEmbedElementSetHeight, htmlEmbedElementGetHeight, - htmlEmbedElementSetName, htmlEmbedElementGetName, - htmlEmbedElementSetSrc, htmlEmbedElementGetSrc, - htmlEmbedElementSetWidth, htmlEmbedElementGetWidth, - HTMLEmbedElement, HTMLEmbedElementClass, castToHTMLEmbedElement, - gTypeHTMLEmbedElement, toHTMLEmbedElement) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.HTMLEmbedElement( +setAlign, +getAlign, +setHeight, +getHeight, +setName, +getName, +setSrc, +getSrc, +setWidth, +getWidth, +HTMLEmbedElement, +castToHTMLEmbedElement, +gTypeHTMLEmbedElement, +HTMLEmbedElementClass, +toHTMLEmbedElement, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -htmlEmbedElementSetAlign :: - (HTMLEmbedElementClass self) => self -> String -> IO () -htmlEmbedElementSetAlign self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_embed_element_set_align #} - (toHTMLEmbedElement self) - valPtr +setAlign :: + (MonadIO m, HTMLEmbedElementClass self, GlibString string) => + self -> string -> m () +setAlign self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_embed_element_set_align #} + (toHTMLEmbedElement self) + valPtr) -htmlEmbedElementGetAlign :: - (HTMLEmbedElementClass self) => self -> IO String -htmlEmbedElementGetAlign self - = ({# call webkit_dom_html_embed_element_get_align #} - (toHTMLEmbedElement self)) - >>= - readUTFString +getAlign :: + (MonadIO m, HTMLEmbedElementClass self, GlibString string) => + self -> m string +getAlign self + = liftIO + (({# call webkit_dom_html_embed_element_get_align #} + (toHTMLEmbedElement self)) + >>= + readUTFString) -htmlEmbedElementSetHeight :: - (HTMLEmbedElementClass self) => self -> Int -> IO () -htmlEmbedElementSetHeight self val - = {# call webkit_dom_html_embed_element_set_height #} - (toHTMLEmbedElement self) - (fromIntegral val) +setHeight :: + (MonadIO m, HTMLEmbedElementClass self) => self -> Int -> m () +setHeight self val + = liftIO + ({# call webkit_dom_html_embed_element_set_height #} + (toHTMLEmbedElement self) + (fromIntegral val)) -htmlEmbedElementGetHeight :: - (HTMLEmbedElementClass self) => self -> IO Int -htmlEmbedElementGetHeight self - = fromIntegral <$> - ({# call webkit_dom_html_embed_element_get_height #} - (toHTMLEmbedElement self)) +getHeight :: + (MonadIO m, HTMLEmbedElementClass self) => self -> m Int +getHeight self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_embed_element_get_height #} + (toHTMLEmbedElement self))) -htmlEmbedElementSetName :: - (HTMLEmbedElementClass self) => self -> String -> IO () -htmlEmbedElementSetName self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_embed_element_set_name #} - (toHTMLEmbedElement self) - valPtr +setName :: + (MonadIO m, HTMLEmbedElementClass self, GlibString string) => + self -> string -> m () +setName self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_embed_element_set_name #} + (toHTMLEmbedElement self) + valPtr) -htmlEmbedElementGetName :: - (HTMLEmbedElementClass self) => self -> IO String -htmlEmbedElementGetName self - = ({# call webkit_dom_html_embed_element_get_name #} - (toHTMLEmbedElement self)) - >>= - readUTFString +getName :: + (MonadIO m, HTMLEmbedElementClass self, GlibString string) => + self -> m string +getName self + = liftIO + (({# call webkit_dom_html_embed_element_get_name #} + (toHTMLEmbedElement self)) + >>= + readUTFString) -htmlEmbedElementSetSrc :: - (HTMLEmbedElementClass self) => self -> String -> IO () -htmlEmbedElementSetSrc self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_embed_element_set_src #} - (toHTMLEmbedElement self) - valPtr +setSrc :: + (MonadIO m, HTMLEmbedElementClass self, GlibString string) => + self -> string -> m () +setSrc self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_embed_element_set_src #} + (toHTMLEmbedElement self) + valPtr) -htmlEmbedElementGetSrc :: - (HTMLEmbedElementClass self) => self -> IO String -htmlEmbedElementGetSrc self - = ({# call webkit_dom_html_embed_element_get_src #} - (toHTMLEmbedElement self)) - >>= - readUTFString +getSrc :: + (MonadIO m, HTMLEmbedElementClass self, GlibString string) => + self -> m string +getSrc self + = liftIO + (({# call webkit_dom_html_embed_element_get_src #} + (toHTMLEmbedElement self)) + >>= + readUTFString) -htmlEmbedElementSetWidth :: - (HTMLEmbedElementClass self) => self -> Int -> IO () -htmlEmbedElementSetWidth self val - = {# call webkit_dom_html_embed_element_set_width #} - (toHTMLEmbedElement self) - (fromIntegral val) +setWidth :: + (MonadIO m, HTMLEmbedElementClass self) => self -> Int -> m () +setWidth self val + = liftIO + ({# call webkit_dom_html_embed_element_set_width #} + (toHTMLEmbedElement self) + (fromIntegral val)) -htmlEmbedElementGetWidth :: - (HTMLEmbedElementClass self) => self -> IO Int -htmlEmbedElementGetWidth self - = fromIntegral <$> - ({# call webkit_dom_html_embed_element_get_width #} - (toHTMLEmbedElement self)) +getWidth :: + (MonadIO m, HTMLEmbedElementClass self) => self -> m Int +getWidth self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_embed_element_get_width #} + (toHTMLEmbedElement self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLFieldSetElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLFieldSetElement.chs --- a/Graphics/UI/Gtk/WebKit/DOM/HTMLFieldSetElement.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLFieldSetElement.chs @@ -1,112 +1,142 @@ -module Graphics.UI.Gtk.WebKit.DOM.HTMLFieldSetElement - (htmlFieldSetElementCheckValidity, - htmlFieldSetElementSetCustomValidity, -#if WEBKIT_CHECK_VERSION(1,10,0) - htmlFieldSetElementSetDisabled, htmlFieldSetElementGetDisabled, +module Graphics.UI.Gtk.WebKit.DOM.HTMLFieldSetElement( +checkValidity, +setCustomValidity, +#if WEBKIT_CHECK_VERSION(2,2,2) +setDisabled, +getDisabled, #endif - htmlFieldSetElementGetForm, -#if WEBKIT_CHECK_VERSION(1,10,0) - htmlFieldSetElementSetName, htmlFieldSetElementGetName, - htmlFieldSetElementGetElements, +getForm, +#if WEBKIT_CHECK_VERSION(2,2,2) +setName, +getName, +getElements, #endif - htmlFieldSetElementGetWillValidate, htmlFieldSetElementGetValidity, - htmlFieldSetElementGetValidationMessage, HTMLFieldSetElement, - HTMLFieldSetElementClass, castToHTMLFieldSetElement, - gTypeHTMLFieldSetElement, toHTMLFieldSetElement) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +getWillValidate, +getValidity, +getValidationMessage, +HTMLFieldSetElement, +castToHTMLFieldSetElement, +gTypeHTMLFieldSetElement, +HTMLFieldSetElementClass, +toHTMLFieldSetElement, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM - -htmlFieldSetElementCheckValidity :: - (HTMLFieldSetElementClass self) => self -> IO Bool -htmlFieldSetElementCheckValidity self - = toBool <$> - ({# call webkit_dom_html_field_set_element_check_validity #} - (toHTMLFieldSetElement self)) +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -htmlFieldSetElementSetCustomValidity :: - (HTMLFieldSetElementClass self) => self -> String -> IO () -htmlFieldSetElementSetCustomValidity self error - = withUTFString error $ - \ errorPtr -> - {# call webkit_dom_html_field_set_element_set_custom_validity #} - (toHTMLFieldSetElement self) - errorPtr +checkValidity :: + (MonadIO m, HTMLFieldSetElementClass self) => self -> m Bool +checkValidity self + = liftIO + (toBool <$> + ({# call webkit_dom_html_field_set_element_check_validity #} + (toHTMLFieldSetElement self))) -#if WEBKIT_CHECK_VERSION(1,10,0) -htmlFieldSetElementSetDisabled :: - (HTMLFieldSetElementClass self) => self -> Bool -> IO () -htmlFieldSetElementSetDisabled self val - = {# call webkit_dom_html_field_set_element_set_disabled #} - (toHTMLFieldSetElement self) - (fromBool val) +setCustomValidity :: + (MonadIO m, HTMLFieldSetElementClass self, GlibString string) => + self -> (Maybe string) -> m () +setCustomValidity self error + = liftIO + (maybeWith withUTFString error $ + \ errorPtr -> + {# call webkit_dom_html_field_set_element_set_custom_validity #} + (toHTMLFieldSetElement self) + errorPtr) + +#if WEBKIT_CHECK_VERSION(2,2,2) +setDisabled :: + (MonadIO m, HTMLFieldSetElementClass self) => self -> Bool -> m () +setDisabled self val + = liftIO + ({# call webkit_dom_html_field_set_element_set_disabled #} + (toHTMLFieldSetElement self) + (fromBool val)) -htmlFieldSetElementGetDisabled :: - (HTMLFieldSetElementClass self) => self -> IO Bool -htmlFieldSetElementGetDisabled self - = toBool <$> - ({# call webkit_dom_html_field_set_element_get_disabled #} - (toHTMLFieldSetElement self)) +getDisabled :: + (MonadIO m, HTMLFieldSetElementClass self) => self -> m Bool +getDisabled self + = liftIO + (toBool <$> + ({# call webkit_dom_html_field_set_element_get_disabled #} + (toHTMLFieldSetElement self))) #endif -htmlFieldSetElementGetForm :: - (HTMLFieldSetElementClass self) => - self -> IO (Maybe HTMLFormElement) -htmlFieldSetElementGetForm self - = maybeNull (makeNewGObject mkHTMLFormElement) - ({# call webkit_dom_html_field_set_element_get_form #} - (toHTMLFieldSetElement self)) - -#if WEBKIT_CHECK_VERSION(1,10,0) -htmlFieldSetElementSetName :: - (HTMLFieldSetElementClass self) => self -> String -> IO () -htmlFieldSetElementSetName self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_field_set_element_set_name #} - (toHTMLFieldSetElement self) - valPtr +getForm :: + (MonadIO m, HTMLFieldSetElementClass self) => + self -> m (Maybe HTMLFormElement) +getForm self + = liftIO + (maybeNull (makeNewGObject mkHTMLFormElement) + ({# call webkit_dom_html_field_set_element_get_form #} + (toHTMLFieldSetElement self))) + +#if WEBKIT_CHECK_VERSION(2,2,2) +setName :: + (MonadIO m, HTMLFieldSetElementClass self, GlibString string) => + self -> string -> m () +setName self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_field_set_element_set_name #} + (toHTMLFieldSetElement self) + valPtr) -htmlFieldSetElementGetName :: - (HTMLFieldSetElementClass self) => self -> IO String -htmlFieldSetElementGetName self - = ({# call webkit_dom_html_field_set_element_get_name #} - (toHTMLFieldSetElement self)) - >>= - readUTFString +getName :: + (MonadIO m, HTMLFieldSetElementClass self, GlibString string) => + self -> m string +getName self + = liftIO + (({# call webkit_dom_html_field_set_element_get_name #} + (toHTMLFieldSetElement self)) + >>= + readUTFString) -htmlFieldSetElementGetElements :: - (HTMLFieldSetElementClass self) => - self -> IO (Maybe HTMLCollection) -htmlFieldSetElementGetElements self - = maybeNull (makeNewGObject mkHTMLCollection) - ({# call webkit_dom_html_field_set_element_get_elements #} - (toHTMLFieldSetElement self)) +getElements :: + (MonadIO m, HTMLFieldSetElementClass self) => + self -> m (Maybe HTMLCollection) +getElements self + = liftIO + (maybeNull (makeNewGObject mkHTMLCollection) + ({# call webkit_dom_html_field_set_element_get_elements #} + (toHTMLFieldSetElement self))) #endif -htmlFieldSetElementGetWillValidate :: - (HTMLFieldSetElementClass self) => self -> IO Bool -htmlFieldSetElementGetWillValidate self - = toBool <$> - ({# call webkit_dom_html_field_set_element_get_will_validate #} - (toHTMLFieldSetElement self)) +getWillValidate :: + (MonadIO m, HTMLFieldSetElementClass self) => self -> m Bool +getWillValidate self + = liftIO + (toBool <$> + ({# call webkit_dom_html_field_set_element_get_will_validate #} + (toHTMLFieldSetElement self))) -htmlFieldSetElementGetValidity :: - (HTMLFieldSetElementClass self) => self -> IO (Maybe ValidityState) -htmlFieldSetElementGetValidity self - = maybeNull (makeNewGObject mkValidityState) - ({# call webkit_dom_html_field_set_element_get_validity #} - (toHTMLFieldSetElement self)) +getValidity :: + (MonadIO m, HTMLFieldSetElementClass self) => + self -> m (Maybe ValidityState) +getValidity self + = liftIO + (maybeNull (makeNewGObject mkValidityState) + ({# call webkit_dom_html_field_set_element_get_validity #} + (toHTMLFieldSetElement self))) -htmlFieldSetElementGetValidationMessage :: - (HTMLFieldSetElementClass self) => self -> IO String -htmlFieldSetElementGetValidationMessage self - = ({# call webkit_dom_html_field_set_element_get_validation_message - #} - (toHTMLFieldSetElement self)) - >>= - readUTFString +getValidationMessage :: + (MonadIO m, HTMLFieldSetElementClass self, GlibString string) => + self -> m string +getValidationMessage self + = liftIO + (({# call webkit_dom_html_field_set_element_get_validation_message + #} + (toHTMLFieldSetElement self)) + >>= + readUTFString) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLFontElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLFontElement.chs --- a/Graphics/UI/Gtk/WebKit/DOM/HTMLFontElement.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLFontElement.chs @@ -1,64 +1,90 @@ -module Graphics.UI.Gtk.WebKit.DOM.HTMLFontElement - (htmlFontElementSetColor, htmlFontElementGetColor, - htmlFontElementSetFace, htmlFontElementGetFace, - htmlFontElementSetSize, htmlFontElementGetSize, HTMLFontElement, - HTMLFontElementClass, castToHTMLFontElement, gTypeHTMLFontElement, - toHTMLFontElement) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.HTMLFontElement( +setColor, +getColor, +setFace, +getFace, +setSize, +getSize, +HTMLFontElement, +castToHTMLFontElement, +gTypeHTMLFontElement, +HTMLFontElementClass, +toHTMLFontElement, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -htmlFontElementSetColor :: - (HTMLFontElementClass self) => self -> String -> IO () -htmlFontElementSetColor self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_font_element_set_color #} - (toHTMLFontElement self) - valPtr +setColor :: + (MonadIO m, HTMLFontElementClass self, GlibString string) => + self -> string -> m () +setColor self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_font_element_set_color #} + (toHTMLFontElement self) + valPtr) -htmlFontElementGetColor :: - (HTMLFontElementClass self) => self -> IO String -htmlFontElementGetColor self - = ({# call webkit_dom_html_font_element_get_color #} - (toHTMLFontElement self)) - >>= - readUTFString +getColor :: + (MonadIO m, HTMLFontElementClass self, GlibString string) => + self -> m string +getColor self + = liftIO + (({# call webkit_dom_html_font_element_get_color #} + (toHTMLFontElement self)) + >>= + readUTFString) -htmlFontElementSetFace :: - (HTMLFontElementClass self) => self -> String -> IO () -htmlFontElementSetFace self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_font_element_set_face #} - (toHTMLFontElement self) - valPtr +setFace :: + (MonadIO m, HTMLFontElementClass self, GlibString string) => + self -> string -> m () +setFace self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_font_element_set_face #} + (toHTMLFontElement self) + valPtr) -htmlFontElementGetFace :: - (HTMLFontElementClass self) => self -> IO String -htmlFontElementGetFace self - = ({# call webkit_dom_html_font_element_get_face #} - (toHTMLFontElement self)) - >>= - readUTFString +getFace :: + (MonadIO m, HTMLFontElementClass self, GlibString string) => + self -> m string +getFace self + = liftIO + (({# call webkit_dom_html_font_element_get_face #} + (toHTMLFontElement self)) + >>= + readUTFString) -htmlFontElementSetSize :: - (HTMLFontElementClass self) => self -> String -> IO () -htmlFontElementSetSize self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_font_element_set_size #} - (toHTMLFontElement self) - valPtr +setSize :: + (MonadIO m, HTMLFontElementClass self, GlibString string) => + self -> string -> m () +setSize self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_font_element_set_size #} + (toHTMLFontElement self) + valPtr) -htmlFontElementGetSize :: - (HTMLFontElementClass self) => self -> IO String -htmlFontElementGetSize self - = ({# call webkit_dom_html_font_element_get_size #} - (toHTMLFontElement self)) - >>= - readUTFString +getSize :: + (MonadIO m, HTMLFontElementClass self, GlibString string) => + self -> m string +getSize self + = liftIO + (({# call webkit_dom_html_font_element_get_size #} + (toHTMLFontElement self)) + >>= + readUTFString) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLFormElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLFormElement.chs --- a/Graphics/UI/Gtk/WebKit/DOM/HTMLFormElement.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLFormElement.chs @@ -1,204 +1,331 @@ -module Graphics.UI.Gtk.WebKit.DOM.HTMLFormElement - (htmlFormElementSubmit, htmlFormElementReset, - htmlFormElementCheckValidity, htmlFormElementSetAcceptCharset, - htmlFormElementGetAcceptCharset, htmlFormElementSetAction, - htmlFormElementGetAction, htmlFormElementSetAutocomplete, - htmlFormElementGetAutocomplete, htmlFormElementSetEnctype, - htmlFormElementGetEnctype, htmlFormElementSetEncoding, - htmlFormElementGetEncoding, htmlFormElementSetMethod, - htmlFormElementGetMethod, htmlFormElementSetName, - htmlFormElementGetName, htmlFormElementSetNoValidate, - htmlFormElementGetNoValidate, htmlFormElementSetTarget, - htmlFormElementGetTarget, htmlFormElementGetElements, - htmlFormElementGetLength, HTMLFormElement, HTMLFormElementClass, - castToHTMLFormElement, gTypeHTMLFormElement, toHTMLFormElement) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.HTMLFormElement( +submit, +reset, +checkValidity, +#if WEBKIT_CHECK_VERSION(99,0,0) +requestAutocomplete, +#endif +setAcceptCharset, +getAcceptCharset, +setAction, +getAction, +setAutocomplete, +getAutocomplete, +setEnctype, +getEnctype, +setEncoding, +getEncoding, +setMethod, +getMethod, +setName, +getName, +setNoValidate, +getNoValidate, +setTarget, +getTarget, +getElements, +getLength, +#if WEBKIT_CHECK_VERSION(2,4,0) +setAutocorrect, +getAutocorrect, +setAutocapitalize, +getAutocapitalize, +#endif +autocomplete, +autocompleteerror, +HTMLFormElement, +castToHTMLFormElement, +gTypeHTMLFormElement, +HTMLFormElementClass, +toHTMLFormElement, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -htmlFormElementSubmit :: - (HTMLFormElementClass self) => self -> IO () -htmlFormElementSubmit self - = {# call webkit_dom_html_form_element_submit #} - (toHTMLFormElement self) +submit :: (MonadIO m, HTMLFormElementClass self) => self -> m () +submit self + = liftIO + ({# call webkit_dom_html_form_element_submit #} + (toHTMLFormElement self)) -htmlFormElementReset :: - (HTMLFormElementClass self) => self -> IO () -htmlFormElementReset self - = {# call webkit_dom_html_form_element_reset #} - (toHTMLFormElement self) +reset :: (MonadIO m, HTMLFormElementClass self) => self -> m () +reset self + = liftIO + ({# call webkit_dom_html_form_element_reset #} + (toHTMLFormElement self)) -htmlFormElementCheckValidity :: - (HTMLFormElementClass self) => self -> IO Bool -htmlFormElementCheckValidity self - = toBool <$> - ({# call webkit_dom_html_form_element_check_validity #} +checkValidity :: + (MonadIO m, HTMLFormElementClass self) => self -> m Bool +checkValidity self + = liftIO + (toBool <$> + ({# call webkit_dom_html_form_element_check_validity #} + (toHTMLFormElement self))) + +#if WEBKIT_CHECK_VERSION(99,0,0) +requestAutocomplete :: + (MonadIO m, HTMLFormElementClass self) => self -> m () +requestAutocomplete self + = liftIO + ({# call webkit_dom_html_form_element_request_autocomplete #} (toHTMLFormElement self)) +#endif -htmlFormElementSetAcceptCharset :: - (HTMLFormElementClass self) => self -> String -> IO () -htmlFormElementSetAcceptCharset self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_form_element_set_accept_charset #} - (toHTMLFormElement self) - valPtr +setAcceptCharset :: + (MonadIO m, HTMLFormElementClass self, GlibString string) => + self -> string -> m () +setAcceptCharset self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_form_element_set_accept_charset #} + (toHTMLFormElement self) + valPtr) -htmlFormElementGetAcceptCharset :: - (HTMLFormElementClass self) => self -> IO String -htmlFormElementGetAcceptCharset self - = ({# call webkit_dom_html_form_element_get_accept_charset #} - (toHTMLFormElement self)) - >>= - readUTFString +getAcceptCharset :: + (MonadIO m, HTMLFormElementClass self, GlibString string) => + self -> m string +getAcceptCharset self + = liftIO + (({# call webkit_dom_html_form_element_get_accept_charset #} + (toHTMLFormElement self)) + >>= + readUTFString) -htmlFormElementSetAction :: - (HTMLFormElementClass self) => self -> String -> IO () -htmlFormElementSetAction self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_form_element_set_action #} - (toHTMLFormElement self) - valPtr +setAction :: + (MonadIO m, HTMLFormElementClass self, GlibString string) => + self -> string -> m () +setAction self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_form_element_set_action #} + (toHTMLFormElement self) + valPtr) -htmlFormElementGetAction :: - (HTMLFormElementClass self) => self -> IO String -htmlFormElementGetAction self - = ({# call webkit_dom_html_form_element_get_action #} - (toHTMLFormElement self)) - >>= - readUTFString +getAction :: + (MonadIO m, HTMLFormElementClass self, GlibString string) => + self -> m string +getAction self + = liftIO + (({# call webkit_dom_html_form_element_get_action #} + (toHTMLFormElement self)) + >>= + readUTFString) -htmlFormElementSetAutocomplete :: - (HTMLFormElementClass self) => self -> String -> IO () -htmlFormElementSetAutocomplete self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_form_element_set_autocomplete #} - (toHTMLFormElement self) - valPtr +setAutocomplete :: + (MonadIO m, HTMLFormElementClass self, GlibString string) => + self -> string -> m () +setAutocomplete self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_form_element_set_autocomplete #} + (toHTMLFormElement self) + valPtr) -htmlFormElementGetAutocomplete :: - (HTMLFormElementClass self) => self -> IO String -htmlFormElementGetAutocomplete self - = ({# call webkit_dom_html_form_element_get_autocomplete #} - (toHTMLFormElement self)) - >>= - readUTFString +getAutocomplete :: + (MonadIO m, HTMLFormElementClass self, GlibString string) => + self -> m string +getAutocomplete self + = liftIO + (({# call webkit_dom_html_form_element_get_autocomplete #} + (toHTMLFormElement self)) + >>= + readUTFString) -htmlFormElementSetEnctype :: - (HTMLFormElementClass self) => self -> String -> IO () -htmlFormElementSetEnctype self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_form_element_set_enctype #} - (toHTMLFormElement self) - valPtr +setEnctype :: + (MonadIO m, HTMLFormElementClass self, GlibString string) => + self -> (Maybe string) -> m () +setEnctype self val + = liftIO + (maybeWith withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_form_element_set_enctype #} + (toHTMLFormElement self) + valPtr) -htmlFormElementGetEnctype :: - (HTMLFormElementClass self) => self -> IO String -htmlFormElementGetEnctype self - = ({# call webkit_dom_html_form_element_get_enctype #} - (toHTMLFormElement self)) - >>= - readUTFString +getEnctype :: + (MonadIO m, HTMLFormElementClass self, GlibString string) => + self -> m (Maybe string) +getEnctype self + = liftIO + (({# call webkit_dom_html_form_element_get_enctype #} + (toHTMLFormElement self)) + >>= + maybePeek readUTFString) -htmlFormElementSetEncoding :: - (HTMLFormElementClass self) => self -> String -> IO () -htmlFormElementSetEncoding self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_form_element_set_encoding #} - (toHTMLFormElement self) - valPtr +setEncoding :: + (MonadIO m, HTMLFormElementClass self, GlibString string) => + self -> (Maybe string) -> m () +setEncoding self val + = liftIO + (maybeWith withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_form_element_set_encoding #} + (toHTMLFormElement self) + valPtr) -htmlFormElementGetEncoding :: - (HTMLFormElementClass self) => self -> IO String -htmlFormElementGetEncoding self - = ({# call webkit_dom_html_form_element_get_encoding #} - (toHTMLFormElement self)) - >>= - readUTFString +getEncoding :: + (MonadIO m, HTMLFormElementClass self, GlibString string) => + self -> m (Maybe string) +getEncoding self + = liftIO + (({# call webkit_dom_html_form_element_get_encoding #} + (toHTMLFormElement self)) + >>= + maybePeek readUTFString) -htmlFormElementSetMethod :: - (HTMLFormElementClass self) => self -> String -> IO () -htmlFormElementSetMethod self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_form_element_set_method #} - (toHTMLFormElement self) - valPtr +setMethod :: + (MonadIO m, HTMLFormElementClass self, GlibString string) => + self -> (Maybe string) -> m () +setMethod self val + = liftIO + (maybeWith withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_form_element_set_method #} + (toHTMLFormElement self) + valPtr) -htmlFormElementGetMethod :: - (HTMLFormElementClass self) => self -> IO String -htmlFormElementGetMethod self - = ({# call webkit_dom_html_form_element_get_method #} - (toHTMLFormElement self)) - >>= - readUTFString +getMethod :: + (MonadIO m, HTMLFormElementClass self, GlibString string) => + self -> m (Maybe string) +getMethod self + = liftIO + (({# call webkit_dom_html_form_element_get_method #} + (toHTMLFormElement self)) + >>= + maybePeek readUTFString) -htmlFormElementSetName :: - (HTMLFormElementClass self) => self -> String -> IO () -htmlFormElementSetName self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_form_element_set_name #} - (toHTMLFormElement self) - valPtr +setName :: + (MonadIO m, HTMLFormElementClass self, GlibString string) => + self -> string -> m () +setName self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_form_element_set_name #} + (toHTMLFormElement self) + valPtr) -htmlFormElementGetName :: - (HTMLFormElementClass self) => self -> IO String -htmlFormElementGetName self - = ({# call webkit_dom_html_form_element_get_name #} - (toHTMLFormElement self)) - >>= - readUTFString +getName :: + (MonadIO m, HTMLFormElementClass self, GlibString string) => + self -> m string +getName self + = liftIO + (({# call webkit_dom_html_form_element_get_name #} + (toHTMLFormElement self)) + >>= + readUTFString) -htmlFormElementSetNoValidate :: - (HTMLFormElementClass self) => self -> Bool -> IO () -htmlFormElementSetNoValidate self val - = {# call webkit_dom_html_form_element_set_no_validate #} - (toHTMLFormElement self) - (fromBool val) +setNoValidate :: + (MonadIO m, HTMLFormElementClass self) => self -> Bool -> m () +setNoValidate self val + = liftIO + ({# call webkit_dom_html_form_element_set_no_validate #} + (toHTMLFormElement self) + (fromBool val)) -htmlFormElementGetNoValidate :: - (HTMLFormElementClass self) => self -> IO Bool -htmlFormElementGetNoValidate self - = toBool <$> - ({# call webkit_dom_html_form_element_get_no_validate #} - (toHTMLFormElement self)) +getNoValidate :: + (MonadIO m, HTMLFormElementClass self) => self -> m Bool +getNoValidate self + = liftIO + (toBool <$> + ({# call webkit_dom_html_form_element_get_no_validate #} + (toHTMLFormElement self))) -htmlFormElementSetTarget :: - (HTMLFormElementClass self) => self -> String -> IO () -htmlFormElementSetTarget self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_form_element_set_target #} - (toHTMLFormElement self) - valPtr +setTarget :: + (MonadIO m, HTMLFormElementClass self, GlibString string) => + self -> string -> m () +setTarget self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_form_element_set_target #} + (toHTMLFormElement self) + valPtr) -htmlFormElementGetTarget :: - (HTMLFormElementClass self) => self -> IO String -htmlFormElementGetTarget self - = ({# call webkit_dom_html_form_element_get_target #} - (toHTMLFormElement self)) - >>= - readUTFString +getTarget :: + (MonadIO m, HTMLFormElementClass self, GlibString string) => + self -> m string +getTarget self + = liftIO + (({# call webkit_dom_html_form_element_get_target #} + (toHTMLFormElement self)) + >>= + readUTFString) -htmlFormElementGetElements :: - (HTMLFormElementClass self) => self -> IO (Maybe HTMLCollection) -htmlFormElementGetElements self - = maybeNull (makeNewGObject mkHTMLCollection) - ({# call webkit_dom_html_form_element_get_elements #} - (toHTMLFormElement self)) +getElements :: + (MonadIO m, HTMLFormElementClass self) => + self -> m (Maybe HTMLCollection) +getElements self + = liftIO + (maybeNull (makeNewGObject mkHTMLCollection) + ({# call webkit_dom_html_form_element_get_elements #} + (toHTMLFormElement self))) -htmlFormElementGetLength :: - (HTMLFormElementClass self) => self -> IO Int -htmlFormElementGetLength self - = fromIntegral <$> - ({# call webkit_dom_html_form_element_get_length #} - (toHTMLFormElement self)) +getLength :: + (MonadIO m, HTMLFormElementClass self) => self -> m Int +getLength self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_form_element_get_length #} + (toHTMLFormElement self))) + +#if WEBKIT_CHECK_VERSION(2,4,0) +setAutocorrect :: + (MonadIO m, HTMLFormElementClass self) => self -> Bool -> m () +setAutocorrect self val + = liftIO + ({# call webkit_dom_html_form_element_set_autocorrect #} + (toHTMLFormElement self) + (fromBool val)) + +getAutocorrect :: + (MonadIO m, HTMLFormElementClass self) => self -> m Bool +getAutocorrect self + = liftIO + (toBool <$> + ({# call webkit_dom_html_form_element_get_autocorrect #} + (toHTMLFormElement self))) + +setAutocapitalize :: + (MonadIO m, HTMLFormElementClass self, GlibString string) => + self -> (Maybe string) -> m () +setAutocapitalize self val + = liftIO + (maybeWith withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_form_element_set_autocapitalize #} + (toHTMLFormElement self) + valPtr) + +getAutocapitalize :: + (MonadIO m, HTMLFormElementClass self, GlibString string) => + self -> m (Maybe string) +getAutocapitalize self + = liftIO + (({# call webkit_dom_html_form_element_get_autocapitalize #} + (toHTMLFormElement self)) + >>= + maybePeek readUTFString) +#endif + +autocomplete :: (HTMLFormElementClass self) => EventName self Event +autocomplete = EventName "autocomplete" + +autocompleteerror :: + (HTMLFormElementClass self) => EventName self Event +autocompleteerror = EventName "autocompleteerror" diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLFrameElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLFrameElement.chs --- a/Graphics/UI/Gtk/WebKit/DOM/HTMLFrameElement.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLFrameElement.chs @@ -1,181 +1,237 @@ -module Graphics.UI.Gtk.WebKit.DOM.HTMLFrameElement - (htmlFrameElementSetFrameBorder, htmlFrameElementGetFrameBorder, - htmlFrameElementSetLongDesc, htmlFrameElementGetLongDesc, - htmlFrameElementSetMarginHeight, htmlFrameElementGetMarginHeight, - htmlFrameElementSetMarginWidth, htmlFrameElementGetMarginWidth, - htmlFrameElementSetName, htmlFrameElementGetName, - htmlFrameElementSetNoResize, htmlFrameElementGetNoResize, - htmlFrameElementSetScrolling, htmlFrameElementGetScrolling, - htmlFrameElementSetSrc, htmlFrameElementGetSrc, - htmlFrameElementGetContentDocument, - htmlFrameElementGetContentWindow, htmlFrameElementGetWidth, - htmlFrameElementGetHeight, HTMLFrameElement, HTMLFrameElementClass, - castToHTMLFrameElement, gTypeHTMLFrameElement, toHTMLFrameElement) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.HTMLFrameElement( +setFrameBorder, +getFrameBorder, +setLongDesc, +getLongDesc, +setMarginHeight, +getMarginHeight, +setMarginWidth, +getMarginWidth, +setName, +getName, +setNoResize, +getNoResize, +setScrolling, +getScrolling, +setSrc, +getSrc, +getContentDocument, +getContentWindow, +getWidth, +getHeight, +HTMLFrameElement, +castToHTMLFrameElement, +gTypeHTMLFrameElement, +HTMLFrameElementClass, +toHTMLFrameElement, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -htmlFrameElementSetFrameBorder :: - (HTMLFrameElementClass self) => self -> String -> IO () -htmlFrameElementSetFrameBorder self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_frame_element_set_frame_border #} - (toHTMLFrameElement self) - valPtr +setFrameBorder :: + (MonadIO m, HTMLFrameElementClass self, GlibString string) => + self -> string -> m () +setFrameBorder self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_frame_element_set_frame_border #} + (toHTMLFrameElement self) + valPtr) -htmlFrameElementGetFrameBorder :: - (HTMLFrameElementClass self) => self -> IO String -htmlFrameElementGetFrameBorder self - = ({# call webkit_dom_html_frame_element_get_frame_border #} - (toHTMLFrameElement self)) - >>= - readUTFString +getFrameBorder :: + (MonadIO m, HTMLFrameElementClass self, GlibString string) => + self -> m string +getFrameBorder self + = liftIO + (({# call webkit_dom_html_frame_element_get_frame_border #} + (toHTMLFrameElement self)) + >>= + readUTFString) -htmlFrameElementSetLongDesc :: - (HTMLFrameElementClass self) => self -> String -> IO () -htmlFrameElementSetLongDesc self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_frame_element_set_long_desc #} - (toHTMLFrameElement self) - valPtr +setLongDesc :: + (MonadIO m, HTMLFrameElementClass self, GlibString string) => + self -> string -> m () +setLongDesc self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_frame_element_set_long_desc #} + (toHTMLFrameElement self) + valPtr) -htmlFrameElementGetLongDesc :: - (HTMLFrameElementClass self) => self -> IO String -htmlFrameElementGetLongDesc self - = ({# call webkit_dom_html_frame_element_get_long_desc #} - (toHTMLFrameElement self)) - >>= - readUTFString +getLongDesc :: + (MonadIO m, HTMLFrameElementClass self, GlibString string) => + self -> m string +getLongDesc self + = liftIO + (({# call webkit_dom_html_frame_element_get_long_desc #} + (toHTMLFrameElement self)) + >>= + readUTFString) -htmlFrameElementSetMarginHeight :: - (HTMLFrameElementClass self) => self -> String -> IO () -htmlFrameElementSetMarginHeight self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_frame_element_set_margin_height #} - (toHTMLFrameElement self) - valPtr +setMarginHeight :: + (MonadIO m, HTMLFrameElementClass self, GlibString string) => + self -> string -> m () +setMarginHeight self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_frame_element_set_margin_height #} + (toHTMLFrameElement self) + valPtr) -htmlFrameElementGetMarginHeight :: - (HTMLFrameElementClass self) => self -> IO String -htmlFrameElementGetMarginHeight self - = ({# call webkit_dom_html_frame_element_get_margin_height #} - (toHTMLFrameElement self)) - >>= - readUTFString +getMarginHeight :: + (MonadIO m, HTMLFrameElementClass self, GlibString string) => + self -> m string +getMarginHeight self + = liftIO + (({# call webkit_dom_html_frame_element_get_margin_height #} + (toHTMLFrameElement self)) + >>= + readUTFString) -htmlFrameElementSetMarginWidth :: - (HTMLFrameElementClass self) => self -> String -> IO () -htmlFrameElementSetMarginWidth self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_frame_element_set_margin_width #} - (toHTMLFrameElement self) - valPtr +setMarginWidth :: + (MonadIO m, HTMLFrameElementClass self, GlibString string) => + self -> string -> m () +setMarginWidth self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_frame_element_set_margin_width #} + (toHTMLFrameElement self) + valPtr) -htmlFrameElementGetMarginWidth :: - (HTMLFrameElementClass self) => self -> IO String -htmlFrameElementGetMarginWidth self - = ({# call webkit_dom_html_frame_element_get_margin_width #} - (toHTMLFrameElement self)) - >>= - readUTFString +getMarginWidth :: + (MonadIO m, HTMLFrameElementClass self, GlibString string) => + self -> m string +getMarginWidth self + = liftIO + (({# call webkit_dom_html_frame_element_get_margin_width #} + (toHTMLFrameElement self)) + >>= + readUTFString) -htmlFrameElementSetName :: - (HTMLFrameElementClass self) => self -> String -> IO () -htmlFrameElementSetName self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_frame_element_set_name #} - (toHTMLFrameElement self) - valPtr +setName :: + (MonadIO m, HTMLFrameElementClass self, GlibString string) => + self -> string -> m () +setName self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_frame_element_set_name #} + (toHTMLFrameElement self) + valPtr) -htmlFrameElementGetName :: - (HTMLFrameElementClass self) => self -> IO String -htmlFrameElementGetName self - = ({# call webkit_dom_html_frame_element_get_name #} - (toHTMLFrameElement self)) - >>= - readUTFString +getName :: + (MonadIO m, HTMLFrameElementClass self, GlibString string) => + self -> m string +getName self + = liftIO + (({# call webkit_dom_html_frame_element_get_name #} + (toHTMLFrameElement self)) + >>= + readUTFString) -htmlFrameElementSetNoResize :: - (HTMLFrameElementClass self) => self -> Bool -> IO () -htmlFrameElementSetNoResize self val - = {# call webkit_dom_html_frame_element_set_no_resize #} - (toHTMLFrameElement self) - (fromBool val) +setNoResize :: + (MonadIO m, HTMLFrameElementClass self) => self -> Bool -> m () +setNoResize self val + = liftIO + ({# call webkit_dom_html_frame_element_set_no_resize #} + (toHTMLFrameElement self) + (fromBool val)) -htmlFrameElementGetNoResize :: - (HTMLFrameElementClass self) => self -> IO Bool -htmlFrameElementGetNoResize self - = toBool <$> - ({# call webkit_dom_html_frame_element_get_no_resize #} - (toHTMLFrameElement self)) +getNoResize :: + (MonadIO m, HTMLFrameElementClass self) => self -> m Bool +getNoResize self + = liftIO + (toBool <$> + ({# call webkit_dom_html_frame_element_get_no_resize #} + (toHTMLFrameElement self))) -htmlFrameElementSetScrolling :: - (HTMLFrameElementClass self) => self -> String -> IO () -htmlFrameElementSetScrolling self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_frame_element_set_scrolling #} - (toHTMLFrameElement self) - valPtr +setScrolling :: + (MonadIO m, HTMLFrameElementClass self, GlibString string) => + self -> string -> m () +setScrolling self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_frame_element_set_scrolling #} + (toHTMLFrameElement self) + valPtr) -htmlFrameElementGetScrolling :: - (HTMLFrameElementClass self) => self -> IO String -htmlFrameElementGetScrolling self - = ({# call webkit_dom_html_frame_element_get_scrolling #} - (toHTMLFrameElement self)) - >>= - readUTFString +getScrolling :: + (MonadIO m, HTMLFrameElementClass self, GlibString string) => + self -> m string +getScrolling self + = liftIO + (({# call webkit_dom_html_frame_element_get_scrolling #} + (toHTMLFrameElement self)) + >>= + readUTFString) -htmlFrameElementSetSrc :: - (HTMLFrameElementClass self) => self -> String -> IO () -htmlFrameElementSetSrc self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_frame_element_set_src #} - (toHTMLFrameElement self) - valPtr +setSrc :: + (MonadIO m, HTMLFrameElementClass self, GlibString string) => + self -> string -> m () +setSrc self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_frame_element_set_src #} + (toHTMLFrameElement self) + valPtr) -htmlFrameElementGetSrc :: - (HTMLFrameElementClass self) => self -> IO String -htmlFrameElementGetSrc self - = ({# call webkit_dom_html_frame_element_get_src #} - (toHTMLFrameElement self)) - >>= - readUTFString +getSrc :: + (MonadIO m, HTMLFrameElementClass self, GlibString string) => + self -> m string +getSrc self + = liftIO + (({# call webkit_dom_html_frame_element_get_src #} + (toHTMLFrameElement self)) + >>= + readUTFString) -htmlFrameElementGetContentDocument :: - (HTMLFrameElementClass self) => self -> IO (Maybe Document) -htmlFrameElementGetContentDocument self - = maybeNull (makeNewGObject mkDocument) - ({# call webkit_dom_html_frame_element_get_content_document #} - (toHTMLFrameElement self)) +getContentDocument :: + (MonadIO m, HTMLFrameElementClass self) => + self -> m (Maybe Document) +getContentDocument self + = liftIO + (maybeNull (makeNewGObject mkDocument) + ({# call webkit_dom_html_frame_element_get_content_document #} + (toHTMLFrameElement self))) -htmlFrameElementGetContentWindow :: - (HTMLFrameElementClass self) => self -> IO (Maybe DOMWindow) -htmlFrameElementGetContentWindow self - = maybeNull (makeNewGObject mkDOMWindow) - ({# call webkit_dom_html_frame_element_get_content_window #} - (toHTMLFrameElement self)) +getContentWindow :: + (MonadIO m, HTMLFrameElementClass self) => self -> m (Maybe Window) +getContentWindow self + = liftIO + (maybeNull (makeNewGObject mkWindow) + ({# call webkit_dom_html_frame_element_get_content_window #} + (toHTMLFrameElement self))) -htmlFrameElementGetWidth :: - (HTMLFrameElementClass self) => self -> IO Int -htmlFrameElementGetWidth self - = fromIntegral <$> - ({# call webkit_dom_html_frame_element_get_width #} - (toHTMLFrameElement self)) +getWidth :: + (MonadIO m, HTMLFrameElementClass self) => self -> m Int +getWidth self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_frame_element_get_width #} + (toHTMLFrameElement self))) -htmlFrameElementGetHeight :: - (HTMLFrameElementClass self) => self -> IO Int -htmlFrameElementGetHeight self - = fromIntegral <$> - ({# call webkit_dom_html_frame_element_get_height #} - (toHTMLFrameElement self)) +getHeight :: + (MonadIO m, HTMLFrameElementClass self) => self -> m Int +getHeight self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_frame_element_get_height #} + (toHTMLFrameElement self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLFrameSetElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLFrameSetElement.chs --- a/Graphics/UI/Gtk/WebKit/DOM/HTMLFrameSetElement.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLFrameSetElement.chs @@ -1,125 +1,126 @@ -module Graphics.UI.Gtk.WebKit.DOM.HTMLFrameSetElement - (htmlFrameSetElementSetCols, htmlFrameSetElementGetCols, - htmlFrameSetElementSetRows, htmlFrameSetElementGetRows, - htmlFrameSetElementOnbeforeunload, htmlFrameSetElementOnhashchange, - htmlFrameSetElementOnmessage, htmlFrameSetElementOnoffline, - htmlFrameSetElementOnonline, htmlFrameSetElementOnpopstate, - htmlFrameSetElementOnresize, htmlFrameSetElementOnstorage, - htmlFrameSetElementOnunload, - htmlFrameSetElementOnorientationchange, htmlFrameSetElementOnblur, - htmlFrameSetElementOnerror, htmlFrameSetElementOnfocus, - htmlFrameSetElementOnload, HTMLFrameSetElement, - HTMLFrameSetElementClass, castToHTMLFrameSetElement, - gTypeHTMLFrameSetElement, toHTMLFrameSetElement) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.HTMLFrameSetElement( +setCols, +getCols, +setRows, +getRows, +beforeUnload, +hashChange, +message, +offline, +online, +popState, +resize, +storage, +unload, +orientationChange, +blur, +error, +focus, +load, +HTMLFrameSetElement, +castToHTMLFrameSetElement, +gTypeHTMLFrameSetElement, +HTMLFrameSetElementClass, +toHTMLFrameSetElement, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -htmlFrameSetElementSetCols :: - (HTMLFrameSetElementClass self) => self -> String -> IO () -htmlFrameSetElementSetCols self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_frame_set_element_set_cols #} - (toHTMLFrameSetElement self) - valPtr +setCols :: + (MonadIO m, HTMLFrameSetElementClass self, GlibString string) => + self -> string -> m () +setCols self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_frame_set_element_set_cols #} + (toHTMLFrameSetElement self) + valPtr) -htmlFrameSetElementGetCols :: - (HTMLFrameSetElementClass self) => self -> IO String -htmlFrameSetElementGetCols self - = ({# call webkit_dom_html_frame_set_element_get_cols #} - (toHTMLFrameSetElement self)) - >>= - readUTFString +getCols :: + (MonadIO m, HTMLFrameSetElementClass self, GlibString string) => + self -> m string +getCols self + = liftIO + (({# call webkit_dom_html_frame_set_element_get_cols #} + (toHTMLFrameSetElement self)) + >>= + readUTFString) -htmlFrameSetElementSetRows :: - (HTMLFrameSetElementClass self) => self -> String -> IO () -htmlFrameSetElementSetRows self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_frame_set_element_set_rows #} - (toHTMLFrameSetElement self) - valPtr +setRows :: + (MonadIO m, HTMLFrameSetElementClass self, GlibString string) => + self -> string -> m () +setRows self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_frame_set_element_set_rows #} + (toHTMLFrameSetElement self) + valPtr) -htmlFrameSetElementGetRows :: - (HTMLFrameSetElementClass self) => self -> IO String -htmlFrameSetElementGetRows self - = ({# call webkit_dom_html_frame_set_element_get_rows #} - (toHTMLFrameSetElement self)) - >>= - readUTFString +getRows :: + (MonadIO m, HTMLFrameSetElementClass self, GlibString string) => + self -> m string +getRows self + = liftIO + (({# call webkit_dom_html_frame_set_element_get_rows #} + (toHTMLFrameSetElement self)) + >>= + readUTFString) -htmlFrameSetElementOnbeforeunload :: - (HTMLFrameSetElementClass self) => - Signal self (EventM UIEvent self ()) -htmlFrameSetElementOnbeforeunload = (connect "beforeunload") +beforeUnload :: + (HTMLFrameSetElementClass self) => EventName self Event +beforeUnload = EventName "beforeunload" -htmlFrameSetElementOnhashchange :: - (HTMLFrameSetElementClass self) => - Signal self (EventM UIEvent self ()) -htmlFrameSetElementOnhashchange = (connect "hashchange") +hashChange :: + (HTMLFrameSetElementClass self) => EventName self Event +hashChange = EventName "hashchange" -htmlFrameSetElementOnmessage :: - (HTMLFrameSetElementClass self) => - Signal self (EventM UIEvent self ()) -htmlFrameSetElementOnmessage = (connect "message") +message :: (HTMLFrameSetElementClass self) => EventName self Event +message = EventName "message" -htmlFrameSetElementOnoffline :: - (HTMLFrameSetElementClass self) => - Signal self (EventM UIEvent self ()) -htmlFrameSetElementOnoffline = (connect "offline") +offline :: (HTMLFrameSetElementClass self) => EventName self Event +offline = EventName "offline" -htmlFrameSetElementOnonline :: - (HTMLFrameSetElementClass self) => - Signal self (EventM UIEvent self ()) -htmlFrameSetElementOnonline = (connect "online") +online :: (HTMLFrameSetElementClass self) => EventName self Event +online = EventName "online" -htmlFrameSetElementOnpopstate :: - (HTMLFrameSetElementClass self) => - Signal self (EventM UIEvent self ()) -htmlFrameSetElementOnpopstate = (connect "popstate") +popState :: (HTMLFrameSetElementClass self) => EventName self Event +popState = EventName "popstate" -htmlFrameSetElementOnresize :: - (HTMLFrameSetElementClass self) => - Signal self (EventM UIEvent self ()) -htmlFrameSetElementOnresize = (connect "resize") +resize :: (HTMLFrameSetElementClass self) => EventName self UIEvent +resize = EventName "resize" -htmlFrameSetElementOnstorage :: - (HTMLFrameSetElementClass self) => - Signal self (EventM UIEvent self ()) -htmlFrameSetElementOnstorage = (connect "storage") +storage :: (HTMLFrameSetElementClass self) => EventName self Event +storage = EventName "storage" -htmlFrameSetElementOnunload :: - (HTMLFrameSetElementClass self) => - Signal self (EventM UIEvent self ()) -htmlFrameSetElementOnunload = (connect "unload") +unload :: (HTMLFrameSetElementClass self) => EventName self UIEvent +unload = EventName "unload" -htmlFrameSetElementOnorientationchange :: - (HTMLFrameSetElementClass self) => - Signal self (EventM UIEvent self ()) -htmlFrameSetElementOnorientationchange - = (connect "orientationchange") +orientationChange :: + (HTMLFrameSetElementClass self) => EventName self Event +orientationChange = EventName "orientationchange" -htmlFrameSetElementOnblur :: - (HTMLFrameSetElementClass self) => - Signal self (EventM UIEvent self ()) -htmlFrameSetElementOnblur = (connect "blur") +blur :: (HTMLFrameSetElementClass self) => EventName self UIEvent +blur = EventName "blur" -htmlFrameSetElementOnerror :: - (HTMLFrameSetElementClass self) => - Signal self (EventM UIEvent self ()) -htmlFrameSetElementOnerror = (connect "error") +error :: (HTMLFrameSetElementClass self) => EventName self UIEvent +error = EventName "error" -htmlFrameSetElementOnfocus :: - (HTMLFrameSetElementClass self) => - Signal self (EventM UIEvent self ()) -htmlFrameSetElementOnfocus = (connect "focus") +focus :: (HTMLFrameSetElementClass self) => EventName self UIEvent +focus = EventName "focus" -htmlFrameSetElementOnload :: - (HTMLFrameSetElementClass self) => - Signal self (EventM UIEvent self ()) -htmlFrameSetElementOnload = (connect "load") +load :: (HTMLFrameSetElementClass self) => EventName self UIEvent +load = EventName "load" diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLHRElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLHRElement.chs --- a/Graphics/UI/Gtk/WebKit/DOM/HTMLHRElement.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLHRElement.chs @@ -1,78 +1,108 @@ -module Graphics.UI.Gtk.WebKit.DOM.HTMLHRElement - (htmlhrElementSetAlign, htmlhrElementGetAlign, - htmlhrElementSetNoShade, htmlhrElementGetNoShade, - htmlhrElementSetSize, htmlhrElementGetSize, htmlhrElementSetWidth, - htmlhrElementGetWidth, HTMLHRElement, HTMLHRElementClass, - castToHTMLHRElement, gTypeHTMLHRElement, toHTMLHRElement) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.HTMLHRElement( +setAlign, +getAlign, +setNoShade, +getNoShade, +setSize, +getSize, +setWidth, +getWidth, +HTMLHRElement, +castToHTMLHRElement, +gTypeHTMLHRElement, +HTMLHRElementClass, +toHTMLHRElement, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -htmlhrElementSetAlign :: - (HTMLHRElementClass self) => self -> String -> IO () -htmlhrElementSetAlign self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_htmlhr_element_set_align #} - (toHTMLHRElement self) - valPtr +setAlign :: + (MonadIO m, HTMLHRElementClass self, GlibString string) => + self -> string -> m () +setAlign self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_htmlhr_element_set_align #} + (toHTMLHRElement self) + valPtr) -htmlhrElementGetAlign :: - (HTMLHRElementClass self) => self -> IO String -htmlhrElementGetAlign self - = ({# call webkit_dom_htmlhr_element_get_align #} - (toHTMLHRElement self)) - >>= - readUTFString +getAlign :: + (MonadIO m, HTMLHRElementClass self, GlibString string) => + self -> m string +getAlign self + = liftIO + (({# call webkit_dom_htmlhr_element_get_align #} + (toHTMLHRElement self)) + >>= + readUTFString) -htmlhrElementSetNoShade :: - (HTMLHRElementClass self) => self -> Bool -> IO () -htmlhrElementSetNoShade self val - = {# call webkit_dom_htmlhr_element_set_no_shade #} - (toHTMLHRElement self) - (fromBool val) +setNoShade :: + (MonadIO m, HTMLHRElementClass self) => self -> Bool -> m () +setNoShade self val + = liftIO + ({# call webkit_dom_htmlhr_element_set_no_shade #} + (toHTMLHRElement self) + (fromBool val)) -htmlhrElementGetNoShade :: - (HTMLHRElementClass self) => self -> IO Bool -htmlhrElementGetNoShade self - = toBool <$> - ({# call webkit_dom_htmlhr_element_get_no_shade #} - (toHTMLHRElement self)) +getNoShade :: + (MonadIO m, HTMLHRElementClass self) => self -> m Bool +getNoShade self + = liftIO + (toBool <$> + ({# call webkit_dom_htmlhr_element_get_no_shade #} + (toHTMLHRElement self))) -htmlhrElementSetSize :: - (HTMLHRElementClass self) => self -> String -> IO () -htmlhrElementSetSize self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_htmlhr_element_set_size #} - (toHTMLHRElement self) - valPtr +setSize :: + (MonadIO m, HTMLHRElementClass self, GlibString string) => + self -> string -> m () +setSize self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_htmlhr_element_set_size #} + (toHTMLHRElement self) + valPtr) -htmlhrElementGetSize :: - (HTMLHRElementClass self) => self -> IO String -htmlhrElementGetSize self - = ({# call webkit_dom_htmlhr_element_get_size #} - (toHTMLHRElement self)) - >>= - readUTFString +getSize :: + (MonadIO m, HTMLHRElementClass self, GlibString string) => + self -> m string +getSize self + = liftIO + (({# call webkit_dom_htmlhr_element_get_size #} + (toHTMLHRElement self)) + >>= + readUTFString) -htmlhrElementSetWidth :: - (HTMLHRElementClass self) => self -> String -> IO () -htmlhrElementSetWidth self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_htmlhr_element_set_width #} - (toHTMLHRElement self) - valPtr +setWidth :: + (MonadIO m, HTMLHRElementClass self, GlibString string) => + self -> string -> m () +setWidth self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_htmlhr_element_set_width #} + (toHTMLHRElement self) + valPtr) -htmlhrElementGetWidth :: - (HTMLHRElementClass self) => self -> IO String -htmlhrElementGetWidth self - = ({# call webkit_dom_htmlhr_element_get_width #} - (toHTMLHRElement self)) - >>= - readUTFString +getWidth :: + (MonadIO m, HTMLHRElementClass self, GlibString string) => + self -> m string +getWidth self + = liftIO + (({# call webkit_dom_htmlhr_element_get_width #} + (toHTMLHRElement self)) + >>= + readUTFString) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLHeadElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLHeadElement.chs --- a/Graphics/UI/Gtk/WebKit/DOM/HTMLHeadElement.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLHeadElement.chs @@ -1,28 +1,44 @@ -module Graphics.UI.Gtk.WebKit.DOM.HTMLHeadElement - (htmlHeadElementSetProfile, htmlHeadElementGetProfile, - HTMLHeadElement, HTMLHeadElementClass, castToHTMLHeadElement, - gTypeHTMLHeadElement, toHTMLHeadElement) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.HTMLHeadElement( +setProfile, +getProfile, +HTMLHeadElement, +castToHTMLHeadElement, +gTypeHTMLHeadElement, +HTMLHeadElementClass, +toHTMLHeadElement, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -htmlHeadElementSetProfile :: - (HTMLHeadElementClass self) => self -> String -> IO () -htmlHeadElementSetProfile self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_head_element_set_profile #} - (toHTMLHeadElement self) - valPtr +setProfile :: + (MonadIO m, HTMLHeadElementClass self, GlibString string) => + self -> string -> m () +setProfile self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_head_element_set_profile #} + (toHTMLHeadElement self) + valPtr) -htmlHeadElementGetProfile :: - (HTMLHeadElementClass self) => self -> IO String -htmlHeadElementGetProfile self - = ({# call webkit_dom_html_head_element_get_profile #} - (toHTMLHeadElement self)) - >>= - readUTFString +getProfile :: + (MonadIO m, HTMLHeadElementClass self, GlibString string) => + self -> m string +getProfile self + = liftIO + (({# call webkit_dom_html_head_element_get_profile #} + (toHTMLHeadElement self)) + >>= + readUTFString) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLHeadingElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLHeadingElement.chs --- a/Graphics/UI/Gtk/WebKit/DOM/HTMLHeadingElement.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLHeadingElement.chs @@ -1,29 +1,44 @@ -module Graphics.UI.Gtk.WebKit.DOM.HTMLHeadingElement - (htmlHeadingElementSetAlign, htmlHeadingElementGetAlign, - HTMLHeadingElement, HTMLHeadingElementClass, - castToHTMLHeadingElement, gTypeHTMLHeadingElement, - toHTMLHeadingElement) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.HTMLHeadingElement( +setAlign, +getAlign, +HTMLHeadingElement, +castToHTMLHeadingElement, +gTypeHTMLHeadingElement, +HTMLHeadingElementClass, +toHTMLHeadingElement, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -htmlHeadingElementSetAlign :: - (HTMLHeadingElementClass self) => self -> String -> IO () -htmlHeadingElementSetAlign self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_heading_element_set_align #} - (toHTMLHeadingElement self) - valPtr +setAlign :: + (MonadIO m, HTMLHeadingElementClass self, GlibString string) => + self -> string -> m () +setAlign self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_heading_element_set_align #} + (toHTMLHeadingElement self) + valPtr) -htmlHeadingElementGetAlign :: - (HTMLHeadingElementClass self) => self -> IO String -htmlHeadingElementGetAlign self - = ({# call webkit_dom_html_heading_element_get_align #} - (toHTMLHeadingElement self)) - >>= - readUTFString +getAlign :: + (MonadIO m, HTMLHeadingElementClass self, GlibString string) => + self -> m string +getAlign self + = liftIO + (({# call webkit_dom_html_heading_element_get_align #} + (toHTMLHeadingElement self)) + >>= + readUTFString) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLHtmlElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLHtmlElement.chs --- a/Graphics/UI/Gtk/WebKit/DOM/HTMLHtmlElement.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLHtmlElement.chs @@ -1,46 +1,67 @@ -module Graphics.UI.Gtk.WebKit.DOM.HTMLHtmlElement - (htmlHtmlElementSetVersion, htmlHtmlElementGetVersion, - htmlHtmlElementSetManifest, htmlHtmlElementGetManifest, - HTMLHtmlElement, HTMLHtmlElementClass, castToHTMLHtmlElement, - gTypeHTMLHtmlElement, toHTMLHtmlElement) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.HTMLHtmlElement( +setVersion, +getVersion, +setManifest, +getManifest, +HTMLHtmlElement, +castToHTMLHtmlElement, +gTypeHTMLHtmlElement, +HTMLHtmlElementClass, +toHTMLHtmlElement, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -htmlHtmlElementSetVersion :: - (HTMLHtmlElementClass self) => self -> String -> IO () -htmlHtmlElementSetVersion self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_html_element_set_version #} - (toHTMLHtmlElement self) - valPtr +setVersion :: + (MonadIO m, HTMLHtmlElementClass self, GlibString string) => + self -> string -> m () +setVersion self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_html_element_set_version #} + (toHTMLHtmlElement self) + valPtr) -htmlHtmlElementGetVersion :: - (HTMLHtmlElementClass self) => self -> IO String -htmlHtmlElementGetVersion self - = ({# call webkit_dom_html_html_element_get_version #} - (toHTMLHtmlElement self)) - >>= - readUTFString +getVersion :: + (MonadIO m, HTMLHtmlElementClass self, GlibString string) => + self -> m string +getVersion self + = liftIO + (({# call webkit_dom_html_html_element_get_version #} + (toHTMLHtmlElement self)) + >>= + readUTFString) -htmlHtmlElementSetManifest :: - (HTMLHtmlElementClass self) => self -> String -> IO () -htmlHtmlElementSetManifest self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_html_element_set_manifest #} - (toHTMLHtmlElement self) - valPtr +setManifest :: + (MonadIO m, HTMLHtmlElementClass self, GlibString string) => + self -> string -> m () +setManifest self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_html_element_set_manifest #} + (toHTMLHtmlElement self) + valPtr) -htmlHtmlElementGetManifest :: - (HTMLHtmlElementClass self) => self -> IO String -htmlHtmlElementGetManifest self - = ({# call webkit_dom_html_html_element_get_manifest #} - (toHTMLHtmlElement self)) - >>= - readUTFString +getManifest :: + (MonadIO m, HTMLHtmlElementClass self, GlibString string) => + self -> m string +getManifest self + = liftIO + (({# call webkit_dom_html_html_element_get_manifest #} + (toHTMLHtmlElement self)) + >>= + readUTFString) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLIFrameElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLIFrameElement.chs --- a/Graphics/UI/Gtk/WebKit/DOM/HTMLIFrameElement.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLIFrameElement.chs @@ -1,265 +1,321 @@ -module Graphics.UI.Gtk.WebKit.DOM.HTMLIFrameElement - (htmliFrameElementSetAlign, htmliFrameElementGetAlign, - htmliFrameElementSetFrameBorder, htmliFrameElementGetFrameBorder, - htmliFrameElementSetHeight, htmliFrameElementGetHeight, - htmliFrameElementSetLongDesc, htmliFrameElementGetLongDesc, - htmliFrameElementSetMarginHeight, htmliFrameElementGetMarginHeight, - htmliFrameElementSetMarginWidth, htmliFrameElementGetMarginWidth, - htmliFrameElementSetName, htmliFrameElementGetName, - htmliFrameElementSetSandbox, htmliFrameElementGetSandbox, -#if WEBKIT_CHECK_VERSION(1,10,0) - htmliFrameElementSetSeamless, htmliFrameElementGetSeamless, -#endif - htmliFrameElementSetScrolling, htmliFrameElementGetScrolling, - htmliFrameElementSetSrc, htmliFrameElementGetSrc, -#if WEBKIT_CHECK_VERSION(1,10,0) - htmliFrameElementSetSrcdoc, htmliFrameElementGetSrcdoc, +module Graphics.UI.Gtk.WebKit.DOM.HTMLIFrameElement( +setAlign, +getAlign, +setFrameBorder, +getFrameBorder, +setHeight, +getHeight, +setLongDesc, +getLongDesc, +setMarginHeight, +getMarginHeight, +setMarginWidth, +getMarginWidth, +setName, +getName, +setSandbox, +getSandbox, +setScrolling, +getScrolling, +setSrc, +getSrc, +#if WEBKIT_CHECK_VERSION(2,2,2) +setSrcdoc, +getSrcdoc, #endif - htmliFrameElementSetWidth, htmliFrameElementGetWidth, - htmliFrameElementGetContentDocument, - htmliFrameElementGetContentWindow, HTMLIFrameElement, - HTMLIFrameElementClass, castToHTMLIFrameElement, - gTypeHTMLIFrameElement, toHTMLIFrameElement) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +setWidth, +getWidth, +getContentDocument, +getContentWindow, +HTMLIFrameElement, +castToHTMLIFrameElement, +gTypeHTMLIFrameElement, +HTMLIFrameElementClass, +toHTMLIFrameElement, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM - -htmliFrameElementSetAlign :: - (HTMLIFrameElementClass self) => self -> String -> IO () -htmliFrameElementSetAlign self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_iframe_element_set_align #} - (toHTMLIFrameElement self) - valPtr - -htmliFrameElementGetAlign :: - (HTMLIFrameElementClass self) => self -> IO String -htmliFrameElementGetAlign self - = ({# call webkit_dom_html_iframe_element_get_align #} - (toHTMLIFrameElement self)) - >>= - readUTFString - -htmliFrameElementSetFrameBorder :: - (HTMLIFrameElementClass self) => self -> String -> IO () -htmliFrameElementSetFrameBorder self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_iframe_element_set_frame_border #} - (toHTMLIFrameElement self) - valPtr +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -htmliFrameElementGetFrameBorder :: - (HTMLIFrameElementClass self) => self -> IO String -htmliFrameElementGetFrameBorder self - = ({# call webkit_dom_html_iframe_element_get_frame_border #} - (toHTMLIFrameElement self)) - >>= - readUTFString +setAlign :: + (MonadIO m, HTMLIFrameElementClass self, GlibString string) => + self -> string -> m () +setAlign self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_iframe_element_set_align #} + (toHTMLIFrameElement self) + valPtr) -htmliFrameElementSetHeight :: - (HTMLIFrameElementClass self) => self -> String -> IO () -htmliFrameElementSetHeight self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_iframe_element_set_height #} - (toHTMLIFrameElement self) - valPtr +getAlign :: + (MonadIO m, HTMLIFrameElementClass self, GlibString string) => + self -> m string +getAlign self + = liftIO + (({# call webkit_dom_html_iframe_element_get_align #} + (toHTMLIFrameElement self)) + >>= + readUTFString) -htmliFrameElementGetHeight :: - (HTMLIFrameElementClass self) => self -> IO String -htmliFrameElementGetHeight self - = ({# call webkit_dom_html_iframe_element_get_height #} - (toHTMLIFrameElement self)) - >>= - readUTFString +setFrameBorder :: + (MonadIO m, HTMLIFrameElementClass self, GlibString string) => + self -> string -> m () +setFrameBorder self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_iframe_element_set_frame_border #} + (toHTMLIFrameElement self) + valPtr) -htmliFrameElementSetLongDesc :: - (HTMLIFrameElementClass self) => self -> String -> IO () -htmliFrameElementSetLongDesc self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_iframe_element_set_long_desc #} - (toHTMLIFrameElement self) - valPtr +getFrameBorder :: + (MonadIO m, HTMLIFrameElementClass self, GlibString string) => + self -> m string +getFrameBorder self + = liftIO + (({# call webkit_dom_html_iframe_element_get_frame_border #} + (toHTMLIFrameElement self)) + >>= + readUTFString) -htmliFrameElementGetLongDesc :: - (HTMLIFrameElementClass self) => self -> IO String -htmliFrameElementGetLongDesc self - = ({# call webkit_dom_html_iframe_element_get_long_desc #} - (toHTMLIFrameElement self)) - >>= - readUTFString +setHeight :: + (MonadIO m, HTMLIFrameElementClass self, GlibString string) => + self -> string -> m () +setHeight self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_iframe_element_set_height #} + (toHTMLIFrameElement self) + valPtr) -htmliFrameElementSetMarginHeight :: - (HTMLIFrameElementClass self) => self -> String -> IO () -htmliFrameElementSetMarginHeight self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_iframe_element_set_margin_height #} - (toHTMLIFrameElement self) - valPtr +getHeight :: + (MonadIO m, HTMLIFrameElementClass self, GlibString string) => + self -> m string +getHeight self + = liftIO + (({# call webkit_dom_html_iframe_element_get_height #} + (toHTMLIFrameElement self)) + >>= + readUTFString) -htmliFrameElementGetMarginHeight :: - (HTMLIFrameElementClass self) => self -> IO String -htmliFrameElementGetMarginHeight self - = ({# call webkit_dom_html_iframe_element_get_margin_height #} - (toHTMLIFrameElement self)) - >>= - readUTFString +setLongDesc :: + (MonadIO m, HTMLIFrameElementClass self, GlibString string) => + self -> string -> m () +setLongDesc self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_iframe_element_set_long_desc #} + (toHTMLIFrameElement self) + valPtr) -htmliFrameElementSetMarginWidth :: - (HTMLIFrameElementClass self) => self -> String -> IO () -htmliFrameElementSetMarginWidth self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_iframe_element_set_margin_width #} - (toHTMLIFrameElement self) - valPtr +getLongDesc :: + (MonadIO m, HTMLIFrameElementClass self, GlibString string) => + self -> m string +getLongDesc self + = liftIO + (({# call webkit_dom_html_iframe_element_get_long_desc #} + (toHTMLIFrameElement self)) + >>= + readUTFString) -htmliFrameElementGetMarginWidth :: - (HTMLIFrameElementClass self) => self -> IO String -htmliFrameElementGetMarginWidth self - = ({# call webkit_dom_html_iframe_element_get_margin_width #} - (toHTMLIFrameElement self)) - >>= - readUTFString +setMarginHeight :: + (MonadIO m, HTMLIFrameElementClass self, GlibString string) => + self -> string -> m () +setMarginHeight self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_iframe_element_set_margin_height #} + (toHTMLIFrameElement self) + valPtr) -htmliFrameElementSetName :: - (HTMLIFrameElementClass self) => self -> String -> IO () -htmliFrameElementSetName self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_iframe_element_set_name #} - (toHTMLIFrameElement self) - valPtr +getMarginHeight :: + (MonadIO m, HTMLIFrameElementClass self, GlibString string) => + self -> m string +getMarginHeight self + = liftIO + (({# call webkit_dom_html_iframe_element_get_margin_height #} + (toHTMLIFrameElement self)) + >>= + readUTFString) -htmliFrameElementGetName :: - (HTMLIFrameElementClass self) => self -> IO String -htmliFrameElementGetName self - = ({# call webkit_dom_html_iframe_element_get_name #} - (toHTMLIFrameElement self)) - >>= - readUTFString +setMarginWidth :: + (MonadIO m, HTMLIFrameElementClass self, GlibString string) => + self -> string -> m () +setMarginWidth self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_iframe_element_set_margin_width #} + (toHTMLIFrameElement self) + valPtr) -htmliFrameElementSetSandbox :: - (HTMLIFrameElementClass self) => self -> String -> IO () -htmliFrameElementSetSandbox self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_iframe_element_set_sandbox #} - (toHTMLIFrameElement self) - valPtr +getMarginWidth :: + (MonadIO m, HTMLIFrameElementClass self, GlibString string) => + self -> m string +getMarginWidth self + = liftIO + (({# call webkit_dom_html_iframe_element_get_margin_width #} + (toHTMLIFrameElement self)) + >>= + readUTFString) -htmliFrameElementGetSandbox :: - (HTMLIFrameElementClass self) => self -> IO String -htmliFrameElementGetSandbox self - = ({# call webkit_dom_html_iframe_element_get_sandbox #} - (toHTMLIFrameElement self)) - >>= - readUTFString +setName :: + (MonadIO m, HTMLIFrameElementClass self, GlibString string) => + self -> string -> m () +setName self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_iframe_element_set_name #} + (toHTMLIFrameElement self) + valPtr) -#if WEBKIT_CHECK_VERSION(1,10,0) -htmliFrameElementSetSeamless :: - (HTMLIFrameElementClass self) => self -> Bool -> IO () -htmliFrameElementSetSeamless self val - = {# call webkit_dom_html_iframe_element_set_seamless #} - (toHTMLIFrameElement self) - (fromBool val) +getName :: + (MonadIO m, HTMLIFrameElementClass self, GlibString string) => + self -> m string +getName self + = liftIO + (({# call webkit_dom_html_iframe_element_get_name #} + (toHTMLIFrameElement self)) + >>= + readUTFString) -htmliFrameElementGetSeamless :: - (HTMLIFrameElementClass self) => self -> IO Bool -htmliFrameElementGetSeamless self - = toBool <$> - ({# call webkit_dom_html_iframe_element_get_seamless #} - (toHTMLIFrameElement self)) -#endif +setSandbox :: + (MonadIO m, HTMLIFrameElementClass self, GlibString string) => + self -> string -> m () +setSandbox self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_iframe_element_set_sandbox #} + (toHTMLIFrameElement self) + valPtr) -htmliFrameElementSetScrolling :: - (HTMLIFrameElementClass self) => self -> String -> IO () -htmliFrameElementSetScrolling self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_iframe_element_set_scrolling #} - (toHTMLIFrameElement self) - valPtr +getSandbox :: + (MonadIO m, HTMLIFrameElementClass self, GlibString string) => + self -> m string +getSandbox self + = liftIO + (({# call webkit_dom_html_iframe_element_get_sandbox #} + (toHTMLIFrameElement self)) + >>= + readUTFString) -htmliFrameElementGetScrolling :: - (HTMLIFrameElementClass self) => self -> IO String -htmliFrameElementGetScrolling self - = ({# call webkit_dom_html_iframe_element_get_scrolling #} - (toHTMLIFrameElement self)) - >>= - readUTFString +setScrolling :: + (MonadIO m, HTMLIFrameElementClass self, GlibString string) => + self -> string -> m () +setScrolling self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_iframe_element_set_scrolling #} + (toHTMLIFrameElement self) + valPtr) -htmliFrameElementSetSrc :: - (HTMLIFrameElementClass self) => self -> String -> IO () -htmliFrameElementSetSrc self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_iframe_element_set_src #} - (toHTMLIFrameElement self) - valPtr +getScrolling :: + (MonadIO m, HTMLIFrameElementClass self, GlibString string) => + self -> m string +getScrolling self + = liftIO + (({# call webkit_dom_html_iframe_element_get_scrolling #} + (toHTMLIFrameElement self)) + >>= + readUTFString) -htmliFrameElementGetSrc :: - (HTMLIFrameElementClass self) => self -> IO String -htmliFrameElementGetSrc self - = ({# call webkit_dom_html_iframe_element_get_src #} - (toHTMLIFrameElement self)) - >>= - readUTFString +setSrc :: + (MonadIO m, HTMLIFrameElementClass self, GlibString string) => + self -> string -> m () +setSrc self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_iframe_element_set_src #} + (toHTMLIFrameElement self) + valPtr) -#if WEBKIT_CHECK_VERSION(1,10,0) -htmliFrameElementSetSrcdoc :: - (HTMLIFrameElementClass self) => self -> String -> IO () -htmliFrameElementSetSrcdoc self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_iframe_element_set_srcdoc #} - (toHTMLIFrameElement self) - valPtr +getSrc :: + (MonadIO m, HTMLIFrameElementClass self, GlibString string) => + self -> m string +getSrc self + = liftIO + (({# call webkit_dom_html_iframe_element_get_src #} + (toHTMLIFrameElement self)) + >>= + readUTFString) + +#if WEBKIT_CHECK_VERSION(2,2,2) +setSrcdoc :: + (MonadIO m, HTMLIFrameElementClass self, GlibString string) => + self -> string -> m () +setSrcdoc self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_iframe_element_set_srcdoc #} + (toHTMLIFrameElement self) + valPtr) -htmliFrameElementGetSrcdoc :: - (HTMLIFrameElementClass self) => self -> IO String -htmliFrameElementGetSrcdoc self - = ({# call webkit_dom_html_iframe_element_get_srcdoc #} - (toHTMLIFrameElement self)) - >>= - readUTFString +getSrcdoc :: + (MonadIO m, HTMLIFrameElementClass self, GlibString string) => + self -> m string +getSrcdoc self + = liftIO + (({# call webkit_dom_html_iframe_element_get_srcdoc #} + (toHTMLIFrameElement self)) + >>= + readUTFString) #endif -htmliFrameElementSetWidth :: - (HTMLIFrameElementClass self) => self -> String -> IO () -htmliFrameElementSetWidth self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_iframe_element_set_width #} - (toHTMLIFrameElement self) - valPtr +setWidth :: + (MonadIO m, HTMLIFrameElementClass self, GlibString string) => + self -> string -> m () +setWidth self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_iframe_element_set_width #} + (toHTMLIFrameElement self) + valPtr) -htmliFrameElementGetWidth :: - (HTMLIFrameElementClass self) => self -> IO String -htmliFrameElementGetWidth self - = ({# call webkit_dom_html_iframe_element_get_width #} - (toHTMLIFrameElement self)) - >>= - readUTFString +getWidth :: + (MonadIO m, HTMLIFrameElementClass self, GlibString string) => + self -> m string +getWidth self + = liftIO + (({# call webkit_dom_html_iframe_element_get_width #} + (toHTMLIFrameElement self)) + >>= + readUTFString) -htmliFrameElementGetContentDocument :: - (HTMLIFrameElementClass self) => self -> IO (Maybe Document) -htmliFrameElementGetContentDocument self - = maybeNull (makeNewGObject mkDocument) - ({# call webkit_dom_html_iframe_element_get_content_document #} - (toHTMLIFrameElement self)) +getContentDocument :: + (MonadIO m, HTMLIFrameElementClass self) => + self -> m (Maybe Document) +getContentDocument self + = liftIO + (maybeNull (makeNewGObject mkDocument) + ({# call webkit_dom_html_iframe_element_get_content_document #} + (toHTMLIFrameElement self))) -htmliFrameElementGetContentWindow :: - (HTMLIFrameElementClass self) => self -> IO (Maybe DOMWindow) -htmliFrameElementGetContentWindow self - = maybeNull (makeNewGObject mkDOMWindow) - ({# call webkit_dom_html_iframe_element_get_content_window #} - (toHTMLIFrameElement self)) +getContentWindow :: + (MonadIO m, HTMLIFrameElementClass self) => + self -> m (Maybe Window) +getContentWindow self + = liftIO + (maybeNull (makeNewGObject mkWindow) + ({# call webkit_dom_html_iframe_element_get_content_window #} + (toHTMLIFrameElement self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLImageElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLImageElement.chs --- a/Graphics/UI/Gtk/WebKit/DOM/HTMLImageElement.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLImageElement.chs @@ -1,306 +1,426 @@ -module Graphics.UI.Gtk.WebKit.DOM.HTMLImageElement - (htmlImageElementSetName, htmlImageElementGetName, - htmlImageElementSetAlign, htmlImageElementGetAlign, - htmlImageElementSetAlt, htmlImageElementGetAlt, - htmlImageElementSetBorder, htmlImageElementGetBorder, - htmlImageElementSetCrossOrigin, htmlImageElementGetCrossOrigin, - htmlImageElementSetHeight, htmlImageElementGetHeight, - htmlImageElementSetHspace, htmlImageElementGetHspace, - htmlImageElementSetIsMap, htmlImageElementGetIsMap, - htmlImageElementSetLongDesc, htmlImageElementGetLongDesc, - htmlImageElementSetSrc, htmlImageElementGetSrc, +module Graphics.UI.Gtk.WebKit.DOM.HTMLImageElement( +setName, +getName, +setAlign, +getAlign, +setAlt, +getAlt, +setBorder, +getBorder, +setCrossOrigin, +getCrossOrigin, +setHeight, +getHeight, +setHspace, +getHspace, +setIsMap, +getIsMap, +setLongDesc, +getLongDesc, +setSrc, +getSrc, #if WEBKIT_CHECK_VERSION(2,2,2) - htmlImageElementSetSrcset, htmlImageElementGetSrcset, +setSrcset, +getSrcset, #endif - htmlImageElementSetUseMap, htmlImageElementGetUseMap, - htmlImageElementSetVspace, htmlImageElementGetVspace, - htmlImageElementSetWidth, htmlImageElementGetWidth, - htmlImageElementGetComplete, htmlImageElementSetLowsrc, - htmlImageElementGetLowsrc, htmlImageElementGetNaturalHeight, - htmlImageElementGetNaturalWidth, htmlImageElementGetX, - htmlImageElementGetY, HTMLImageElement, HTMLImageElementClass, - castToHTMLImageElement, gTypeHTMLImageElement, toHTMLImageElement) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +#if WEBKIT_CHECK_VERSION(99,0,0) +setSizes, +getSizes, +getCurrentSrc, +#endif +setUseMap, +getUseMap, +setVspace, +getVspace, +setWidth, +getWidth, +getComplete, +setLowsrc, +getLowsrc, +getNaturalHeight, +getNaturalWidth, +getX, +getY, +HTMLImageElement, +castToHTMLImageElement, +gTypeHTMLImageElement, +HTMLImageElementClass, +toHTMLImageElement, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM - -htmlImageElementSetName :: - (HTMLImageElementClass self) => self -> String -> IO () -htmlImageElementSetName self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_image_element_set_name #} - (toHTMLImageElement self) - valPtr +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -htmlImageElementGetName :: - (HTMLImageElementClass self) => self -> IO String -htmlImageElementGetName self - = ({# call webkit_dom_html_image_element_get_name #} - (toHTMLImageElement self)) - >>= - readUTFString +setName :: + (MonadIO m, HTMLImageElementClass self, GlibString string) => + self -> string -> m () +setName self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_image_element_set_name #} + (toHTMLImageElement self) + valPtr) -htmlImageElementSetAlign :: - (HTMLImageElementClass self) => self -> String -> IO () -htmlImageElementSetAlign self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_image_element_set_align #} - (toHTMLImageElement self) - valPtr +getName :: + (MonadIO m, HTMLImageElementClass self, GlibString string) => + self -> m string +getName self + = liftIO + (({# call webkit_dom_html_image_element_get_name #} + (toHTMLImageElement self)) + >>= + readUTFString) -htmlImageElementGetAlign :: - (HTMLImageElementClass self) => self -> IO String -htmlImageElementGetAlign self - = ({# call webkit_dom_html_image_element_get_align #} - (toHTMLImageElement self)) - >>= - readUTFString +setAlign :: + (MonadIO m, HTMLImageElementClass self, GlibString string) => + self -> string -> m () +setAlign self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_image_element_set_align #} + (toHTMLImageElement self) + valPtr) -htmlImageElementSetAlt :: - (HTMLImageElementClass self) => self -> String -> IO () -htmlImageElementSetAlt self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_image_element_set_alt #} - (toHTMLImageElement self) - valPtr +getAlign :: + (MonadIO m, HTMLImageElementClass self, GlibString string) => + self -> m string +getAlign self + = liftIO + (({# call webkit_dom_html_image_element_get_align #} + (toHTMLImageElement self)) + >>= + readUTFString) -htmlImageElementGetAlt :: - (HTMLImageElementClass self) => self -> IO String -htmlImageElementGetAlt self - = ({# call webkit_dom_html_image_element_get_alt #} - (toHTMLImageElement self)) - >>= - readUTFString +setAlt :: + (MonadIO m, HTMLImageElementClass self, GlibString string) => + self -> string -> m () +setAlt self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_image_element_set_alt #} + (toHTMLImageElement self) + valPtr) -htmlImageElementSetBorder :: - (HTMLImageElementClass self) => self -> String -> IO () -htmlImageElementSetBorder self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_image_element_set_border #} - (toHTMLImageElement self) - valPtr +getAlt :: + (MonadIO m, HTMLImageElementClass self, GlibString string) => + self -> m string +getAlt self + = liftIO + (({# call webkit_dom_html_image_element_get_alt #} + (toHTMLImageElement self)) + >>= + readUTFString) -htmlImageElementGetBorder :: - (HTMLImageElementClass self) => self -> IO String -htmlImageElementGetBorder self - = ({# call webkit_dom_html_image_element_get_border #} - (toHTMLImageElement self)) - >>= - readUTFString +setBorder :: + (MonadIO m, HTMLImageElementClass self, GlibString string) => + self -> string -> m () +setBorder self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_image_element_set_border #} + (toHTMLImageElement self) + valPtr) -htmlImageElementSetCrossOrigin :: - (HTMLImageElementClass self) => self -> String -> IO () -htmlImageElementSetCrossOrigin self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_image_element_set_cross_origin #} - (toHTMLImageElement self) - valPtr +getBorder :: + (MonadIO m, HTMLImageElementClass self, GlibString string) => + self -> m string +getBorder self + = liftIO + (({# call webkit_dom_html_image_element_get_border #} + (toHTMLImageElement self)) + >>= + readUTFString) -htmlImageElementGetCrossOrigin :: - (HTMLImageElementClass self) => self -> IO String -htmlImageElementGetCrossOrigin self - = ({# call webkit_dom_html_image_element_get_cross_origin #} - (toHTMLImageElement self)) - >>= - readUTFString +setCrossOrigin :: + (MonadIO m, HTMLImageElementClass self, GlibString string) => + self -> string -> m () +setCrossOrigin self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_image_element_set_cross_origin #} + (toHTMLImageElement self) + valPtr) -htmlImageElementSetHeight :: - (HTMLImageElementClass self) => self -> Int -> IO () -htmlImageElementSetHeight self val - = {# call webkit_dom_html_image_element_set_height #} - (toHTMLImageElement self) - (fromIntegral val) +getCrossOrigin :: + (MonadIO m, HTMLImageElementClass self, GlibString string) => + self -> m string +getCrossOrigin self + = liftIO + (({# call webkit_dom_html_image_element_get_cross_origin #} + (toHTMLImageElement self)) + >>= + readUTFString) -htmlImageElementGetHeight :: - (HTMLImageElementClass self) => self -> IO Int -htmlImageElementGetHeight self - = fromIntegral <$> - ({# call webkit_dom_html_image_element_get_height #} - (toHTMLImageElement self)) +setHeight :: + (MonadIO m, HTMLImageElementClass self) => self -> Int -> m () +setHeight self val + = liftIO + ({# call webkit_dom_html_image_element_set_height #} + (toHTMLImageElement self) + (fromIntegral val)) -htmlImageElementSetHspace :: - (HTMLImageElementClass self) => self -> Int -> IO () -htmlImageElementSetHspace self val - = {# call webkit_dom_html_image_element_set_hspace #} - (toHTMLImageElement self) - (fromIntegral val) +getHeight :: + (MonadIO m, HTMLImageElementClass self) => self -> m Int +getHeight self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_image_element_get_height #} + (toHTMLImageElement self))) -htmlImageElementGetHspace :: - (HTMLImageElementClass self) => self -> IO Int -htmlImageElementGetHspace self - = fromIntegral <$> - ({# call webkit_dom_html_image_element_get_hspace #} - (toHTMLImageElement self)) +setHspace :: + (MonadIO m, HTMLImageElementClass self) => self -> Int -> m () +setHspace self val + = liftIO + ({# call webkit_dom_html_image_element_set_hspace #} + (toHTMLImageElement self) + (fromIntegral val)) -htmlImageElementSetIsMap :: - (HTMLImageElementClass self) => self -> Bool -> IO () -htmlImageElementSetIsMap self val - = {# call webkit_dom_html_image_element_set_is_map #} - (toHTMLImageElement self) - (fromBool val) +getHspace :: + (MonadIO m, HTMLImageElementClass self) => self -> m Int +getHspace self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_image_element_get_hspace #} + (toHTMLImageElement self))) -htmlImageElementGetIsMap :: - (HTMLImageElementClass self) => self -> IO Bool -htmlImageElementGetIsMap self - = toBool <$> - ({# call webkit_dom_html_image_element_get_is_map #} - (toHTMLImageElement self)) +setIsMap :: + (MonadIO m, HTMLImageElementClass self) => self -> Bool -> m () +setIsMap self val + = liftIO + ({# call webkit_dom_html_image_element_set_is_map #} + (toHTMLImageElement self) + (fromBool val)) -htmlImageElementSetLongDesc :: - (HTMLImageElementClass self) => self -> String -> IO () -htmlImageElementSetLongDesc self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_image_element_set_long_desc #} - (toHTMLImageElement self) - valPtr +getIsMap :: + (MonadIO m, HTMLImageElementClass self) => self -> m Bool +getIsMap self + = liftIO + (toBool <$> + ({# call webkit_dom_html_image_element_get_is_map #} + (toHTMLImageElement self))) -htmlImageElementGetLongDesc :: - (HTMLImageElementClass self) => self -> IO String -htmlImageElementGetLongDesc self - = ({# call webkit_dom_html_image_element_get_long_desc #} - (toHTMLImageElement self)) - >>= - readUTFString +setLongDesc :: + (MonadIO m, HTMLImageElementClass self, GlibString string) => + self -> string -> m () +setLongDesc self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_image_element_set_long_desc #} + (toHTMLImageElement self) + valPtr) -htmlImageElementSetSrc :: - (HTMLImageElementClass self) => self -> String -> IO () -htmlImageElementSetSrc self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_image_element_set_src #} - (toHTMLImageElement self) - valPtr +getLongDesc :: + (MonadIO m, HTMLImageElementClass self, GlibString string) => + self -> m string +getLongDesc self + = liftIO + (({# call webkit_dom_html_image_element_get_long_desc #} + (toHTMLImageElement self)) + >>= + readUTFString) -htmlImageElementGetSrc :: - (HTMLImageElementClass self) => self -> IO String -htmlImageElementGetSrc self - = ({# call webkit_dom_html_image_element_get_src #} - (toHTMLImageElement self)) - >>= - readUTFString +setSrc :: + (MonadIO m, HTMLImageElementClass self, GlibString string) => + self -> string -> m () +setSrc self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_image_element_set_src #} + (toHTMLImageElement self) + valPtr) -#if WEBKIT_CHECK_VERSION(2,2,2) -htmlImageElementSetSrcset :: - (HTMLImageElementClass self) => self -> String -> IO () -htmlImageElementSetSrcset self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_image_element_set_srcset #} - (toHTMLImageElement self) - valPtr +getSrc :: + (MonadIO m, HTMLImageElementClass self, GlibString string) => + self -> m string +getSrc self + = liftIO + (({# call webkit_dom_html_image_element_get_src #} + (toHTMLImageElement self)) + >>= + readUTFString) + +#if WEBKIT_CHECK_VERSION(2,2,2) +setSrcset :: + (MonadIO m, HTMLImageElementClass self, GlibString string) => + self -> string -> m () +setSrcset self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_image_element_set_srcset #} + (toHTMLImageElement self) + valPtr) -htmlImageElementGetSrcset :: - (HTMLImageElementClass self) => self -> IO String -htmlImageElementGetSrcset self - = ({# call webkit_dom_html_image_element_get_srcset #} - (toHTMLImageElement self)) - >>= - readUTFString +getSrcset :: + (MonadIO m, HTMLImageElementClass self, GlibString string) => + self -> m string +getSrcset self + = liftIO + (({# call webkit_dom_html_image_element_get_srcset #} + (toHTMLImageElement self)) + >>= + readUTFString) #endif -htmlImageElementSetUseMap :: - (HTMLImageElementClass self) => self -> String -> IO () -htmlImageElementSetUseMap self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_image_element_set_use_map #} - (toHTMLImageElement self) - valPtr +#if WEBKIT_CHECK_VERSION(99,0,0) +setSizes :: + (MonadIO m, HTMLImageElementClass self, GlibString string) => + self -> string -> m () +setSizes self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_image_element_set_sizes #} + (toHTMLImageElement self) + valPtr) -htmlImageElementGetUseMap :: - (HTMLImageElementClass self) => self -> IO String -htmlImageElementGetUseMap self - = ({# call webkit_dom_html_image_element_get_use_map #} - (toHTMLImageElement self)) - >>= - readUTFString +getSizes :: + (MonadIO m, HTMLImageElementClass self, GlibString string) => + self -> m string +getSizes self + = liftIO + (({# call webkit_dom_html_image_element_get_sizes #} + (toHTMLImageElement self)) + >>= + readUTFString) -htmlImageElementSetVspace :: - (HTMLImageElementClass self) => self -> Int -> IO () -htmlImageElementSetVspace self val - = {# call webkit_dom_html_image_element_set_vspace #} - (toHTMLImageElement self) - (fromIntegral val) +getCurrentSrc :: + (MonadIO m, HTMLImageElementClass self, GlibString string) => + self -> m string +getCurrentSrc self + = liftIO + (({# call webkit_dom_html_image_element_get_current_src #} + (toHTMLImageElement self)) + >>= + readUTFString) +#endif -htmlImageElementGetVspace :: - (HTMLImageElementClass self) => self -> IO Int -htmlImageElementGetVspace self - = fromIntegral <$> - ({# call webkit_dom_html_image_element_get_vspace #} - (toHTMLImageElement self)) +setUseMap :: + (MonadIO m, HTMLImageElementClass self, GlibString string) => + self -> string -> m () +setUseMap self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_image_element_set_use_map #} + (toHTMLImageElement self) + valPtr) -htmlImageElementSetWidth :: - (HTMLImageElementClass self) => self -> Int -> IO () -htmlImageElementSetWidth self val - = {# call webkit_dom_html_image_element_set_width #} - (toHTMLImageElement self) - (fromIntegral val) +getUseMap :: + (MonadIO m, HTMLImageElementClass self, GlibString string) => + self -> m string +getUseMap self + = liftIO + (({# call webkit_dom_html_image_element_get_use_map #} + (toHTMLImageElement self)) + >>= + readUTFString) -htmlImageElementGetWidth :: - (HTMLImageElementClass self) => self -> IO Int -htmlImageElementGetWidth self - = fromIntegral <$> - ({# call webkit_dom_html_image_element_get_width #} - (toHTMLImageElement self)) +setVspace :: + (MonadIO m, HTMLImageElementClass self) => self -> Int -> m () +setVspace self val + = liftIO + ({# call webkit_dom_html_image_element_set_vspace #} + (toHTMLImageElement self) + (fromIntegral val)) -htmlImageElementGetComplete :: - (HTMLImageElementClass self) => self -> IO Bool -htmlImageElementGetComplete self - = toBool <$> - ({# call webkit_dom_html_image_element_get_complete #} - (toHTMLImageElement self)) +getVspace :: + (MonadIO m, HTMLImageElementClass self) => self -> m Int +getVspace self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_image_element_get_vspace #} + (toHTMLImageElement self))) -htmlImageElementSetLowsrc :: - (HTMLImageElementClass self) => self -> String -> IO () -htmlImageElementSetLowsrc self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_image_element_set_lowsrc #} - (toHTMLImageElement self) - valPtr +setWidth :: + (MonadIO m, HTMLImageElementClass self) => self -> Int -> m () +setWidth self val + = liftIO + ({# call webkit_dom_html_image_element_set_width #} + (toHTMLImageElement self) + (fromIntegral val)) -htmlImageElementGetLowsrc :: - (HTMLImageElementClass self) => self -> IO String -htmlImageElementGetLowsrc self - = ({# call webkit_dom_html_image_element_get_lowsrc #} - (toHTMLImageElement self)) - >>= - readUTFString +getWidth :: + (MonadIO m, HTMLImageElementClass self) => self -> m Int +getWidth self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_image_element_get_width #} + (toHTMLImageElement self))) -htmlImageElementGetNaturalHeight :: - (HTMLImageElementClass self) => self -> IO Int -htmlImageElementGetNaturalHeight self - = fromIntegral <$> - ({# call webkit_dom_html_image_element_get_natural_height #} - (toHTMLImageElement self)) +getComplete :: + (MonadIO m, HTMLImageElementClass self) => self -> m Bool +getComplete self + = liftIO + (toBool <$> + ({# call webkit_dom_html_image_element_get_complete #} + (toHTMLImageElement self))) -htmlImageElementGetNaturalWidth :: - (HTMLImageElementClass self) => self -> IO Int -htmlImageElementGetNaturalWidth self - = fromIntegral <$> - ({# call webkit_dom_html_image_element_get_natural_width #} - (toHTMLImageElement self)) +setLowsrc :: + (MonadIO m, HTMLImageElementClass self, GlibString string) => + self -> string -> m () +setLowsrc self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_image_element_set_lowsrc #} + (toHTMLImageElement self) + valPtr) -htmlImageElementGetX :: - (HTMLImageElementClass self) => self -> IO Int -htmlImageElementGetX self - = fromIntegral <$> - ({# call webkit_dom_html_image_element_get_x #} - (toHTMLImageElement self)) +getLowsrc :: + (MonadIO m, HTMLImageElementClass self, GlibString string) => + self -> m string +getLowsrc self + = liftIO + (({# call webkit_dom_html_image_element_get_lowsrc #} + (toHTMLImageElement self)) + >>= + readUTFString) -htmlImageElementGetY :: - (HTMLImageElementClass self) => self -> IO Int -htmlImageElementGetY self - = fromIntegral <$> - ({# call webkit_dom_html_image_element_get_y #} - (toHTMLImageElement self)) +getNaturalHeight :: + (MonadIO m, HTMLImageElementClass self) => self -> m Int +getNaturalHeight self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_image_element_get_natural_height #} + (toHTMLImageElement self))) + +getNaturalWidth :: + (MonadIO m, HTMLImageElementClass self) => self -> m Int +getNaturalWidth self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_image_element_get_natural_width #} + (toHTMLImageElement self))) + +getX :: (MonadIO m, HTMLImageElementClass self) => self -> m Int +getX self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_image_element_get_x #} + (toHTMLImageElement self))) + +getY :: (MonadIO m, HTMLImageElementClass self) => self -> m Int +getY self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_image_element_get_y #} + (toHTMLImageElement self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLInputElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLInputElement.chs --- a/Graphics/UI/Gtk/WebKit/DOM/HTMLInputElement.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLInputElement.chs @@ -1,815 +1,988 @@ -module Graphics.UI.Gtk.WebKit.DOM.HTMLInputElement - (htmlInputElementStepUp, htmlInputElementStepDown, - htmlInputElementCheckValidity, htmlInputElementSetCustomValidity, - htmlInputElementSelect, -#if WEBKIT_CHECK_VERSION(2,2,2) - htmlInputElementSetRangeText, -#endif - htmlInputElementSetValueForUser, - htmlInputElementSetAccept, htmlInputElementGetAccept, - htmlInputElementSetAlt, htmlInputElementGetAlt, - htmlInputElementSetAutocomplete, htmlInputElementGetAutocomplete, - htmlInputElementSetAutofocus, htmlInputElementGetAutofocus, - htmlInputElementSetDefaultChecked, - htmlInputElementGetDefaultChecked, htmlInputElementSetChecked, - htmlInputElementGetChecked, htmlInputElementSetDirName, - htmlInputElementGetDirName, htmlInputElementSetDisabled, - htmlInputElementGetDisabled, htmlInputElementGetForm, -#if WEBKIT_CHECK_VERSION(1,10,0) - htmlInputElementSetFiles, -#endif - htmlInputElementGetFiles, - htmlInputElementSetFormAction, htmlInputElementGetFormAction, - htmlInputElementSetFormEnctype, htmlInputElementGetFormEnctype, - htmlInputElementSetFormMethod, htmlInputElementGetFormMethod, - htmlInputElementSetFormNoValidate, - htmlInputElementGetFormNoValidate, htmlInputElementSetFormTarget, - htmlInputElementGetFormTarget, -#if WEBKIT_CHECK_VERSION(1,10,0) - htmlInputElementSetHeight, htmlInputElementGetHeight, -#endif - htmlInputElementSetIndeterminate, - htmlInputElementGetIndeterminate, htmlInputElementGetList, - htmlInputElementSetMax, htmlInputElementGetMax, - htmlInputElementSetMaxLength, htmlInputElementGetMaxLength, - htmlInputElementSetMin, htmlInputElementGetMin, - htmlInputElementSetMultiple, htmlInputElementGetMultiple, - htmlInputElementSetName, htmlInputElementGetName, - htmlInputElementSetPattern, htmlInputElementGetPattern, - htmlInputElementSetPlaceholder, htmlInputElementGetPlaceholder, - htmlInputElementSetReadOnly, htmlInputElementGetReadOnly, - htmlInputElementSetRequired, htmlInputElementGetRequired, - htmlInputElementSetSize, htmlInputElementGetSize, - htmlInputElementSetSrc, htmlInputElementGetSrc, - htmlInputElementSetStep, htmlInputElementGetStep, - htmlInputElementSetDefaultValue, htmlInputElementGetDefaultValue, - htmlInputElementSetValue, htmlInputElementGetValue, - htmlInputElementSetValueAsNumber, htmlInputElementGetValueAsNumber, -#if WEBKIT_CHECK_VERSION(1,10,0) - htmlInputElementSetWidth, htmlInputElementGetWidth, -#endif - htmlInputElementGetWillValidate, htmlInputElementGetValidity, - htmlInputElementGetValidationMessage, htmlInputElementGetLabels, - htmlInputElementSetAlign, htmlInputElementGetAlign, - htmlInputElementSetWebkitdirectory, - htmlInputElementGetWebkitdirectory, htmlInputElementSetUseMap, - htmlInputElementGetUseMap, htmlInputElementSetIncremental, - htmlInputElementGetIncremental, htmlInputElementSetWebkitSpeech, - htmlInputElementGetWebkitSpeech, htmlInputElementSetWebkitGrammar, - htmlInputElementGetWebkitGrammar, - htmlInputElementOnwebkitspeechchange, -#if WEBKIT_CHECK_VERSION(1,10,0) - htmlInputElementSetCapture, htmlInputElementGetCapture, -#endif - HTMLInputElement, HTMLInputElementClass, castToHTMLInputElement, - gTypeHTMLInputElement, toHTMLInputElement) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} -import System.Glib.GError -import Graphics.UI.Gtk.WebKit.DOM.EventM - -htmlInputElementStepUp :: - (HTMLInputElementClass self) => self -> Int -> IO () -htmlInputElementStepUp self n - = propagateGError $ - \ errorPtr_ -> - {# call webkit_dom_html_input_element_step_up #} - (toHTMLInputElement self) - (fromIntegral n) - errorPtr_ - -htmlInputElementStepDown :: - (HTMLInputElementClass self) => self -> Int -> IO () -htmlInputElementStepDown self n - = propagateGError $ - \ errorPtr_ -> - {# call webkit_dom_html_input_element_step_down #} - (toHTMLInputElement self) - (fromIntegral n) - errorPtr_ - -htmlInputElementCheckValidity :: - (HTMLInputElementClass self) => self -> IO Bool -htmlInputElementCheckValidity self - = toBool <$> - ({# call webkit_dom_html_input_element_check_validity #} - (toHTMLInputElement self)) - -htmlInputElementSetCustomValidity :: - (HTMLInputElementClass self) => self -> String -> IO () -htmlInputElementSetCustomValidity self error - = withUTFString error $ - \ errorPtr -> - {# call webkit_dom_html_input_element_set_custom_validity #} - (toHTMLInputElement self) - errorPtr - -htmlInputElementSelect :: - (HTMLInputElementClass self) => self -> IO () -htmlInputElementSelect self - = {# call webkit_dom_html_input_element_select #} - (toHTMLInputElement self) - -#if WEBKIT_CHECK_VERSION(2,2,2) -htmlInputElementSetRangeText :: - (HTMLInputElementClass self) => - self -> String -> Word -> Word -> String -> IO () -htmlInputElementSetRangeText self replacement start end - selectionMode - = propagateGError $ - \ errorPtr_ -> - withUTFString selectionMode $ - \ selectionModePtr -> - withUTFString replacement $ - \ replacementPtr -> - {# call webkit_dom_html_input_element_set_range_text #} - (toHTMLInputElement self) - replacementPtr - (fromIntegral start) - (fromIntegral end) - selectionModePtr - errorPtr_ -#endif - -htmlInputElementSetValueForUser :: - (HTMLInputElementClass self) => self -> String -> IO () -htmlInputElementSetValueForUser self value - = withUTFString value $ - \ valuePtr -> - {# call webkit_dom_html_input_element_set_value_for_user #} - (toHTMLInputElement self) - valuePtr - -htmlInputElementSetAccept :: - (HTMLInputElementClass self) => self -> String -> IO () -htmlInputElementSetAccept self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_input_element_set_accept #} - (toHTMLInputElement self) - valPtr - -htmlInputElementGetAccept :: - (HTMLInputElementClass self) => self -> IO String -htmlInputElementGetAccept self - = ({# call webkit_dom_html_input_element_get_accept #} - (toHTMLInputElement self)) - >>= - readUTFString - -htmlInputElementSetAlt :: - (HTMLInputElementClass self) => self -> String -> IO () -htmlInputElementSetAlt self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_input_element_set_alt #} - (toHTMLInputElement self) - valPtr - -htmlInputElementGetAlt :: - (HTMLInputElementClass self) => self -> IO String -htmlInputElementGetAlt self - = ({# call webkit_dom_html_input_element_get_alt #} - (toHTMLInputElement self)) - >>= - readUTFString - -htmlInputElementSetAutocomplete :: - (HTMLInputElementClass self) => self -> String -> IO () -htmlInputElementSetAutocomplete self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_input_element_set_autocomplete #} - (toHTMLInputElement self) - valPtr - -htmlInputElementGetAutocomplete :: - (HTMLInputElementClass self) => self -> IO String -htmlInputElementGetAutocomplete self - = ({# call webkit_dom_html_input_element_get_autocomplete #} - (toHTMLInputElement self)) - >>= - readUTFString - -htmlInputElementSetAutofocus :: - (HTMLInputElementClass self) => self -> Bool -> IO () -htmlInputElementSetAutofocus self val - = {# call webkit_dom_html_input_element_set_autofocus #} - (toHTMLInputElement self) - (fromBool val) - -htmlInputElementGetAutofocus :: - (HTMLInputElementClass self) => self -> IO Bool -htmlInputElementGetAutofocus self - = toBool <$> - ({# call webkit_dom_html_input_element_get_autofocus #} - (toHTMLInputElement self)) - -htmlInputElementSetDefaultChecked :: - (HTMLInputElementClass self) => self -> Bool -> IO () -htmlInputElementSetDefaultChecked self val - = {# call webkit_dom_html_input_element_set_default_checked #} - (toHTMLInputElement self) - (fromBool val) - -htmlInputElementGetDefaultChecked :: - (HTMLInputElementClass self) => self -> IO Bool -htmlInputElementGetDefaultChecked self - = toBool <$> - ({# call webkit_dom_html_input_element_get_default_checked #} - (toHTMLInputElement self)) - -htmlInputElementSetChecked :: - (HTMLInputElementClass self) => self -> Bool -> IO () -htmlInputElementSetChecked self val - = {# call webkit_dom_html_input_element_set_checked #} - (toHTMLInputElement self) - (fromBool val) - -htmlInputElementGetChecked :: - (HTMLInputElementClass self) => self -> IO Bool -htmlInputElementGetChecked self - = toBool <$> - ({# call webkit_dom_html_input_element_get_checked #} - (toHTMLInputElement self)) - -htmlInputElementSetDirName :: - (HTMLInputElementClass self) => self -> String -> IO () -htmlInputElementSetDirName self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_input_element_set_dir_name #} - (toHTMLInputElement self) - valPtr - -htmlInputElementGetDirName :: - (HTMLInputElementClass self) => self -> IO String -htmlInputElementGetDirName self - = ({# call webkit_dom_html_input_element_get_dir_name #} - (toHTMLInputElement self)) - >>= - readUTFString - -htmlInputElementSetDisabled :: - (HTMLInputElementClass self) => self -> Bool -> IO () -htmlInputElementSetDisabled self val - = {# call webkit_dom_html_input_element_set_disabled #} - (toHTMLInputElement self) - (fromBool val) - -htmlInputElementGetDisabled :: - (HTMLInputElementClass self) => self -> IO Bool -htmlInputElementGetDisabled self - = toBool <$> - ({# call webkit_dom_html_input_element_get_disabled #} - (toHTMLInputElement self)) - -htmlInputElementGetForm :: - (HTMLInputElementClass self) => self -> IO (Maybe HTMLFormElement) -htmlInputElementGetForm self - = maybeNull (makeNewGObject mkHTMLFormElement) - ({# call webkit_dom_html_input_element_get_form #} - (toHTMLInputElement self)) - -#if WEBKIT_CHECK_VERSION(1,10,0) -htmlInputElementSetFiles :: - (FileListClass val, HTMLInputElementClass self) => - self -> Maybe val -> IO () -htmlInputElementSetFiles self val - = {# call webkit_dom_html_input_element_set_files #} - (toHTMLInputElement self) - (maybe (FileList nullForeignPtr) toFileList val) -#endif - -htmlInputElementGetFiles :: - (HTMLInputElementClass self) => self -> IO (Maybe FileList) -htmlInputElementGetFiles self - = maybeNull (makeNewGObject mkFileList) - ({# call webkit_dom_html_input_element_get_files #} - (toHTMLInputElement self)) - -htmlInputElementSetFormAction :: - (HTMLInputElementClass self) => self -> String -> IO () -htmlInputElementSetFormAction self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_input_element_set_form_action #} - (toHTMLInputElement self) - valPtr - -htmlInputElementGetFormAction :: - (HTMLInputElementClass self) => self -> IO String -htmlInputElementGetFormAction self - = ({# call webkit_dom_html_input_element_get_form_action #} - (toHTMLInputElement self)) - >>= - readUTFString - -htmlInputElementSetFormEnctype :: - (HTMLInputElementClass self) => self -> String -> IO () -htmlInputElementSetFormEnctype self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_input_element_set_form_enctype #} - (toHTMLInputElement self) - valPtr - -htmlInputElementGetFormEnctype :: - (HTMLInputElementClass self) => self -> IO String -htmlInputElementGetFormEnctype self - = ({# call webkit_dom_html_input_element_get_form_enctype #} - (toHTMLInputElement self)) - >>= - readUTFString - -htmlInputElementSetFormMethod :: - (HTMLInputElementClass self) => self -> String -> IO () -htmlInputElementSetFormMethod self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_input_element_set_form_method #} - (toHTMLInputElement self) - valPtr - -htmlInputElementGetFormMethod :: - (HTMLInputElementClass self) => self -> IO String -htmlInputElementGetFormMethod self - = ({# call webkit_dom_html_input_element_get_form_method #} - (toHTMLInputElement self)) - >>= - readUTFString - -htmlInputElementSetFormNoValidate :: - (HTMLInputElementClass self) => self -> Bool -> IO () -htmlInputElementSetFormNoValidate self val - = {# call webkit_dom_html_input_element_set_form_no_validate #} - (toHTMLInputElement self) - (fromBool val) - -htmlInputElementGetFormNoValidate :: - (HTMLInputElementClass self) => self -> IO Bool -htmlInputElementGetFormNoValidate self - = toBool <$> - ({# call webkit_dom_html_input_element_get_form_no_validate #} - (toHTMLInputElement self)) - -htmlInputElementSetFormTarget :: - (HTMLInputElementClass self) => self -> String -> IO () -htmlInputElementSetFormTarget self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_input_element_set_form_target #} - (toHTMLInputElement self) - valPtr - -htmlInputElementGetFormTarget :: - (HTMLInputElementClass self) => self -> IO String -htmlInputElementGetFormTarget self - = ({# call webkit_dom_html_input_element_get_form_target #} - (toHTMLInputElement self)) - >>= - readUTFString - -#if WEBKIT_CHECK_VERSION(1,10,0) -htmlInputElementSetHeight :: - (HTMLInputElementClass self) => self -> Word -> IO () -htmlInputElementSetHeight self val - = {# call webkit_dom_html_input_element_set_height #} - (toHTMLInputElement self) - (fromIntegral val) - -htmlInputElementGetHeight :: - (HTMLInputElementClass self) => self -> IO Word -htmlInputElementGetHeight self - = fromIntegral <$> - ({# call webkit_dom_html_input_element_get_height #} - (toHTMLInputElement self)) -#endif - -htmlInputElementSetIndeterminate :: - (HTMLInputElementClass self) => self -> Bool -> IO () -htmlInputElementSetIndeterminate self val - = {# call webkit_dom_html_input_element_set_indeterminate #} - (toHTMLInputElement self) - (fromBool val) - -htmlInputElementGetIndeterminate :: - (HTMLInputElementClass self) => self -> IO Bool -htmlInputElementGetIndeterminate self - = toBool <$> - ({# call webkit_dom_html_input_element_get_indeterminate #} - (toHTMLInputElement self)) - -htmlInputElementGetList :: - (HTMLInputElementClass self) => self -> IO (Maybe HTMLElement) -htmlInputElementGetList self - = maybeNull (makeNewGObject mkHTMLElement) - ({# call webkit_dom_html_input_element_get_list #} - (toHTMLInputElement self)) - -htmlInputElementSetMax :: - (HTMLInputElementClass self) => self -> String -> IO () -htmlInputElementSetMax self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_input_element_set_max #} - (toHTMLInputElement self) - valPtr - -htmlInputElementGetMax :: - (HTMLInputElementClass self) => self -> IO String -htmlInputElementGetMax self - = ({# call webkit_dom_html_input_element_get_max #} - (toHTMLInputElement self)) - >>= - readUTFString - -htmlInputElementSetMaxLength :: - (HTMLInputElementClass self) => self -> Int -> IO () -htmlInputElementSetMaxLength self val - = propagateGError $ - \ errorPtr_ -> - {# call webkit_dom_html_input_element_set_max_length #} - (toHTMLInputElement self) - (fromIntegral val) - errorPtr_ - -htmlInputElementGetMaxLength :: - (HTMLInputElementClass self) => self -> IO Int -htmlInputElementGetMaxLength self - = fromIntegral <$> - ({# call webkit_dom_html_input_element_get_max_length #} - (toHTMLInputElement self)) - -htmlInputElementSetMin :: - (HTMLInputElementClass self) => self -> String -> IO () -htmlInputElementSetMin self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_input_element_set_min #} - (toHTMLInputElement self) - valPtr - -htmlInputElementGetMin :: - (HTMLInputElementClass self) => self -> IO String -htmlInputElementGetMin self - = ({# call webkit_dom_html_input_element_get_min #} - (toHTMLInputElement self)) - >>= - readUTFString - -htmlInputElementSetMultiple :: - (HTMLInputElementClass self) => self -> Bool -> IO () -htmlInputElementSetMultiple self val - = {# call webkit_dom_html_input_element_set_multiple #} - (toHTMLInputElement self) - (fromBool val) - -htmlInputElementGetMultiple :: - (HTMLInputElementClass self) => self -> IO Bool -htmlInputElementGetMultiple self - = toBool <$> - ({# call webkit_dom_html_input_element_get_multiple #} - (toHTMLInputElement self)) - -htmlInputElementSetName :: - (HTMLInputElementClass self) => self -> String -> IO () -htmlInputElementSetName self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_input_element_set_name #} - (toHTMLInputElement self) - valPtr - -htmlInputElementGetName :: - (HTMLInputElementClass self) => self -> IO String -htmlInputElementGetName self - = ({# call webkit_dom_html_input_element_get_name #} - (toHTMLInputElement self)) - >>= - readUTFString - -htmlInputElementSetPattern :: - (HTMLInputElementClass self) => self -> String -> IO () -htmlInputElementSetPattern self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_input_element_set_pattern #} - (toHTMLInputElement self) - valPtr - -htmlInputElementGetPattern :: - (HTMLInputElementClass self) => self -> IO String -htmlInputElementGetPattern self - = ({# call webkit_dom_html_input_element_get_pattern #} - (toHTMLInputElement self)) - >>= - readUTFString - -htmlInputElementSetPlaceholder :: - (HTMLInputElementClass self) => self -> String -> IO () -htmlInputElementSetPlaceholder self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_input_element_set_placeholder #} - (toHTMLInputElement self) - valPtr - -htmlInputElementGetPlaceholder :: - (HTMLInputElementClass self) => self -> IO String -htmlInputElementGetPlaceholder self - = ({# call webkit_dom_html_input_element_get_placeholder #} - (toHTMLInputElement self)) - >>= - readUTFString - -htmlInputElementSetReadOnly :: - (HTMLInputElementClass self) => self -> Bool -> IO () -htmlInputElementSetReadOnly self val - = {# call webkit_dom_html_input_element_set_read_only #} - (toHTMLInputElement self) - (fromBool val) - -htmlInputElementGetReadOnly :: - (HTMLInputElementClass self) => self -> IO Bool -htmlInputElementGetReadOnly self - = toBool <$> - ({# call webkit_dom_html_input_element_get_read_only #} - (toHTMLInputElement self)) - -htmlInputElementSetRequired :: - (HTMLInputElementClass self) => self -> Bool -> IO () -htmlInputElementSetRequired self val - = {# call webkit_dom_html_input_element_set_required #} - (toHTMLInputElement self) - (fromBool val) - -htmlInputElementGetRequired :: - (HTMLInputElementClass self) => self -> IO Bool -htmlInputElementGetRequired self - = toBool <$> - ({# call webkit_dom_html_input_element_get_required #} - (toHTMLInputElement self)) - -htmlInputElementSetSize :: (HTMLInputElementClass self) => self -> Word -> IO () -#if WEBKIT_CHECK_VERSION(2,0,0) -htmlInputElementSetSize self val = propagateGError $ \errorPtr -> - {# call webkit_dom_html_input_element_set_size #} (toHTMLInputElement self) (fromIntegral val) errorPtr -#else -htmlInputElementSetSize self val = {# call webkit_dom_html_input_element_set_size #} (toHTMLInputElement self) (fromIntegral val) -#endif - -htmlInputElementGetSize :: - (HTMLInputElementClass self) => self -> IO Word -htmlInputElementGetSize self - = fromIntegral <$> - ({# call webkit_dom_html_input_element_get_size #} - (toHTMLInputElement self)) - -htmlInputElementSetSrc :: - (HTMLInputElementClass self) => self -> String -> IO () -htmlInputElementSetSrc self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_input_element_set_src #} - (toHTMLInputElement self) - valPtr - -htmlInputElementGetSrc :: - (HTMLInputElementClass self) => self -> IO String -htmlInputElementGetSrc self - = ({# call webkit_dom_html_input_element_get_src #} - (toHTMLInputElement self)) - >>= - readUTFString - -htmlInputElementSetStep :: - (HTMLInputElementClass self) => self -> String -> IO () -htmlInputElementSetStep self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_input_element_set_step #} - (toHTMLInputElement self) - valPtr - -htmlInputElementGetStep :: - (HTMLInputElementClass self) => self -> IO String -htmlInputElementGetStep self - = ({# call webkit_dom_html_input_element_get_step #} - (toHTMLInputElement self)) - >>= - readUTFString - -htmlInputElementSetDefaultValue :: - (HTMLInputElementClass self) => self -> String -> IO () -htmlInputElementSetDefaultValue self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_input_element_set_default_value #} - (toHTMLInputElement self) - valPtr - -htmlInputElementGetDefaultValue :: - (HTMLInputElementClass self) => self -> IO String -htmlInputElementGetDefaultValue self - = ({# call webkit_dom_html_input_element_get_default_value #} - (toHTMLInputElement self)) - >>= - readUTFString - -htmlInputElementSetValue :: - (HTMLInputElementClass self) => self -> String -> IO () -htmlInputElementSetValue self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_input_element_set_value #} - (toHTMLInputElement self) - valPtr - -htmlInputElementGetValue :: - (HTMLInputElementClass self) => self -> IO String -htmlInputElementGetValue self - = ({# call webkit_dom_html_input_element_get_value #} - (toHTMLInputElement self)) - >>= - readUTFString - -htmlInputElementSetValueAsNumber :: - (HTMLInputElementClass self) => self -> Double -> IO () -htmlInputElementSetValueAsNumber self val - = propagateGError $ - \ errorPtr_ -> - {# call webkit_dom_html_input_element_set_value_as_number #} - (toHTMLInputElement self) - (realToFrac val) - errorPtr_ - -htmlInputElementGetValueAsNumber :: - (HTMLInputElementClass self) => self -> IO Double -htmlInputElementGetValueAsNumber self - = realToFrac <$> - ({# call webkit_dom_html_input_element_get_value_as_number #} - (toHTMLInputElement self)) - -#if WEBKIT_CHECK_VERSION(1,10,0) -htmlInputElementSetWidth :: - (HTMLInputElementClass self) => self -> Word -> IO () -htmlInputElementSetWidth self val - = {# call webkit_dom_html_input_element_set_width #} - (toHTMLInputElement self) - (fromIntegral val) - -htmlInputElementGetWidth :: - (HTMLInputElementClass self) => self -> IO Word -htmlInputElementGetWidth self - = fromIntegral <$> - ({# call webkit_dom_html_input_element_get_width #} - (toHTMLInputElement self)) -#endif - -htmlInputElementGetWillValidate :: - (HTMLInputElementClass self) => self -> IO Bool -htmlInputElementGetWillValidate self - = toBool <$> - ({# call webkit_dom_html_input_element_get_will_validate #} - (toHTMLInputElement self)) - -htmlInputElementGetValidity :: - (HTMLInputElementClass self) => self -> IO (Maybe ValidityState) -htmlInputElementGetValidity self - = maybeNull (makeNewGObject mkValidityState) - ({# call webkit_dom_html_input_element_get_validity #} - (toHTMLInputElement self)) - -htmlInputElementGetValidationMessage :: - (HTMLInputElementClass self) => self -> IO String -htmlInputElementGetValidationMessage self - = ({# call webkit_dom_html_input_element_get_validation_message #} - (toHTMLInputElement self)) - >>= - readUTFString - -htmlInputElementGetLabels :: - (HTMLInputElementClass self) => self -> IO (Maybe NodeList) -htmlInputElementGetLabels self - = maybeNull (makeNewGObject mkNodeList) - ({# call webkit_dom_html_input_element_get_labels #} - (toHTMLInputElement self)) - -htmlInputElementSetAlign :: - (HTMLInputElementClass self) => self -> String -> IO () -htmlInputElementSetAlign self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_input_element_set_align #} - (toHTMLInputElement self) - valPtr - -htmlInputElementGetAlign :: - (HTMLInputElementClass self) => self -> IO String -htmlInputElementGetAlign self - = ({# call webkit_dom_html_input_element_get_align #} - (toHTMLInputElement self)) - >>= - readUTFString - -htmlInputElementSetWebkitdirectory :: - (HTMLInputElementClass self) => self -> Bool -> IO () -htmlInputElementSetWebkitdirectory self val - = {# call webkit_dom_html_input_element_set_webkitdirectory #} - (toHTMLInputElement self) - (fromBool val) - -htmlInputElementGetWebkitdirectory :: - (HTMLInputElementClass self) => self -> IO Bool -htmlInputElementGetWebkitdirectory self - = toBool <$> - ({# call webkit_dom_html_input_element_get_webkitdirectory #} - (toHTMLInputElement self)) - -htmlInputElementSetUseMap :: - (HTMLInputElementClass self) => self -> String -> IO () -htmlInputElementSetUseMap self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_input_element_set_use_map #} - (toHTMLInputElement self) - valPtr - -htmlInputElementGetUseMap :: - (HTMLInputElementClass self) => self -> IO String -htmlInputElementGetUseMap self - = ({# call webkit_dom_html_input_element_get_use_map #} - (toHTMLInputElement self)) - >>= - readUTFString - -htmlInputElementSetIncremental :: - (HTMLInputElementClass self) => self -> Bool -> IO () -htmlInputElementSetIncremental self val - = {# call webkit_dom_html_input_element_set_incremental #} - (toHTMLInputElement self) - (fromBool val) - -htmlInputElementGetIncremental :: - (HTMLInputElementClass self) => self -> IO Bool -htmlInputElementGetIncremental self - = toBool <$> - ({# call webkit_dom_html_input_element_get_incremental #} - (toHTMLInputElement self)) - -htmlInputElementSetWebkitSpeech :: - (HTMLInputElementClass self) => self -> Bool -> IO () -htmlInputElementSetWebkitSpeech self val - = {# call webkit_dom_html_input_element_set_webkit_speech #} - (toHTMLInputElement self) - (fromBool val) - -htmlInputElementGetWebkitSpeech :: - (HTMLInputElementClass self) => self -> IO Bool -htmlInputElementGetWebkitSpeech self - = toBool <$> - ({# call webkit_dom_html_input_element_get_webkit_speech #} - (toHTMLInputElement self)) - -htmlInputElementSetWebkitGrammar :: - (HTMLInputElementClass self) => self -> Bool -> IO () -htmlInputElementSetWebkitGrammar self val - = {# call webkit_dom_html_input_element_set_webkit_grammar #} - (toHTMLInputElement self) - (fromBool val) - -htmlInputElementGetWebkitGrammar :: - (HTMLInputElementClass self) => self -> IO Bool -htmlInputElementGetWebkitGrammar self - = toBool <$> - ({# call webkit_dom_html_input_element_get_webkit_grammar #} - (toHTMLInputElement self)) - -htmlInputElementOnwebkitspeechchange :: - (HTMLInputElementClass self) => - Signal self (EventM UIEvent self ()) -htmlInputElementOnwebkitspeechchange - = (connect "webkitspeechchange") - -#if WEBKIT_CHECK_VERSION(1,10,0) -htmlInputElementSetCapture :: - (HTMLInputElementClass self) => self -> String -> IO () -htmlInputElementSetCapture self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_input_element_set_capture #} - (toHTMLInputElement self) - valPtr - -htmlInputElementGetCapture :: - (HTMLInputElementClass self) => self -> IO String -htmlInputElementGetCapture self - = ({# call webkit_dom_html_input_element_get_capture #} - (toHTMLInputElement self)) - >>= - readUTFString +module Graphics.UI.Gtk.WebKit.DOM.HTMLInputElement( +stepUp, +stepDown, +checkValidity, +setCustomValidity, +select, +#if WEBKIT_CHECK_VERSION(2,2,2) +setRangeText4, +#endif +setValueForUser, +setAccept, +getAccept, +setAlt, +getAlt, +setAutocomplete, +getAutocomplete, +setAutofocus, +getAutofocus, +setDefaultChecked, +getDefaultChecked, +setChecked, +getChecked, +setDirName, +getDirName, +setDisabled, +getDisabled, +getForm, +#if WEBKIT_CHECK_VERSION(2,2,2) +setFiles, +#endif +getFiles, +setFormAction, +getFormAction, +setFormEnctype, +getFormEnctype, +setFormMethod, +getFormMethod, +setFormNoValidate, +getFormNoValidate, +setFormTarget, +getFormTarget, +#if WEBKIT_CHECK_VERSION(2,2,2) +setHeight, +getHeight, +#endif +setIndeterminate, +getIndeterminate, +getList, +setMax, +getMax, +setMaxLength, +getMaxLength, +setMin, +getMin, +setMultiple, +getMultiple, +setName, +getName, +setPattern, +getPattern, +setPlaceholder, +getPlaceholder, +setReadOnly, +getReadOnly, +setRequired, +getRequired, +#if WEBKIT_CHECK_VERSION(2,2,2) +setSize, +#endif +getSize, +setSrc, +getSrc, +setStep, +getStep, +setDefaultValue, +getDefaultValue, +setValue, +getValue, +setValueAsNumber, +getValueAsNumber, +#if WEBKIT_CHECK_VERSION(2,2,2) +setWidth, +getWidth, +#endif +getWillValidate, +getValidity, +getValidationMessage, +getLabels, +setAlign, +getAlign, +setUseMap, +getUseMap, +setIncremental, +getIncremental, +#if WEBKIT_CHECK_VERSION(2,4,0) +setAutocorrect, +getAutocorrect, +setAutocapitalize, +getAutocapitalize, +#endif +#if WEBKIT_CHECK_VERSION(2,7,0) +setCapture, +getCapture, +#endif +HTMLInputElement, +castToHTMLInputElement, +gTypeHTMLInputElement, +HTMLInputElementClass, +toHTMLInputElement, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures +import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + + +stepUp :: + (MonadIO m, HTMLInputElementClass self) => self -> Int -> m () +stepUp self n + = liftIO + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_html_input_element_step_up #} + (toHTMLInputElement self) + (fromIntegral n) + errorPtr_) + +stepDown :: + (MonadIO m, HTMLInputElementClass self) => self -> Int -> m () +stepDown self n + = liftIO + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_html_input_element_step_down #} + (toHTMLInputElement self) + (fromIntegral n) + errorPtr_) + +checkValidity :: + (MonadIO m, HTMLInputElementClass self) => self -> m Bool +checkValidity self + = liftIO + (toBool <$> + ({# call webkit_dom_html_input_element_check_validity #} + (toHTMLInputElement self))) + +setCustomValidity :: + (MonadIO m, HTMLInputElementClass self, GlibString string) => + self -> (Maybe string) -> m () +setCustomValidity self error + = liftIO + (maybeWith withUTFString error $ + \ errorPtr -> + {# call webkit_dom_html_input_element_set_custom_validity #} + (toHTMLInputElement self) + errorPtr) + +select :: (MonadIO m, HTMLInputElementClass self) => self -> m () +select self + = liftIO + ({# call webkit_dom_html_input_element_select #} + (toHTMLInputElement self)) + +#if WEBKIT_CHECK_VERSION(2,2,2) +setRangeText4 :: + (MonadIO m, HTMLInputElementClass self, GlibString string) => + self -> string -> Word -> Word -> string -> m () +setRangeText4 self replacement start end selectionMode + = liftIO + (propagateGError $ + \ errorPtr_ -> + withUTFString selectionMode $ + \ selectionModePtr -> + withUTFString replacement $ + \ replacementPtr -> + {# call webkit_dom_html_input_element_set_range_text #} + (toHTMLInputElement self) + replacementPtr + (fromIntegral start) + (fromIntegral end) + selectionModePtr + errorPtr_) +#endif + +setValueForUser :: + (MonadIO m, HTMLInputElementClass self, GlibString string) => + self -> (Maybe string) -> m () +setValueForUser self value + = liftIO + (maybeWith withUTFString value $ + \ valuePtr -> + {# call webkit_dom_html_input_element_set_value_for_user #} + (toHTMLInputElement self) + valuePtr) + +setAccept :: + (MonadIO m, HTMLInputElementClass self, GlibString string) => + self -> string -> m () +setAccept self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_input_element_set_accept #} + (toHTMLInputElement self) + valPtr) + +getAccept :: + (MonadIO m, HTMLInputElementClass self, GlibString string) => + self -> m string +getAccept self + = liftIO + (({# call webkit_dom_html_input_element_get_accept #} + (toHTMLInputElement self)) + >>= + readUTFString) + +setAlt :: + (MonadIO m, HTMLInputElementClass self, GlibString string) => + self -> string -> m () +setAlt self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_input_element_set_alt #} + (toHTMLInputElement self) + valPtr) + +getAlt :: + (MonadIO m, HTMLInputElementClass self, GlibString string) => + self -> m string +getAlt self + = liftIO + (({# call webkit_dom_html_input_element_get_alt #} + (toHTMLInputElement self)) + >>= + readUTFString) + +setAutocomplete :: + (MonadIO m, HTMLInputElementClass self, GlibString string) => + self -> string -> m () +setAutocomplete self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_input_element_set_autocomplete #} + (toHTMLInputElement self) + valPtr) + +getAutocomplete :: + (MonadIO m, HTMLInputElementClass self, GlibString string) => + self -> m string +getAutocomplete self + = liftIO + (({# call webkit_dom_html_input_element_get_autocomplete #} + (toHTMLInputElement self)) + >>= + readUTFString) + +setAutofocus :: + (MonadIO m, HTMLInputElementClass self) => self -> Bool -> m () +setAutofocus self val + = liftIO + ({# call webkit_dom_html_input_element_set_autofocus #} + (toHTMLInputElement self) + (fromBool val)) + +getAutofocus :: + (MonadIO m, HTMLInputElementClass self) => self -> m Bool +getAutofocus self + = liftIO + (toBool <$> + ({# call webkit_dom_html_input_element_get_autofocus #} + (toHTMLInputElement self))) + +setDefaultChecked :: + (MonadIO m, HTMLInputElementClass self) => self -> Bool -> m () +setDefaultChecked self val + = liftIO + ({# call webkit_dom_html_input_element_set_default_checked #} + (toHTMLInputElement self) + (fromBool val)) + +getDefaultChecked :: + (MonadIO m, HTMLInputElementClass self) => self -> m Bool +getDefaultChecked self + = liftIO + (toBool <$> + ({# call webkit_dom_html_input_element_get_default_checked #} + (toHTMLInputElement self))) + +setChecked :: + (MonadIO m, HTMLInputElementClass self) => self -> Bool -> m () +setChecked self val + = liftIO + ({# call webkit_dom_html_input_element_set_checked #} + (toHTMLInputElement self) + (fromBool val)) + +getChecked :: + (MonadIO m, HTMLInputElementClass self) => self -> m Bool +getChecked self + = liftIO + (toBool <$> + ({# call webkit_dom_html_input_element_get_checked #} + (toHTMLInputElement self))) + +setDirName :: + (MonadIO m, HTMLInputElementClass self, GlibString string) => + self -> string -> m () +setDirName self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_input_element_set_dir_name #} + (toHTMLInputElement self) + valPtr) + +getDirName :: + (MonadIO m, HTMLInputElementClass self, GlibString string) => + self -> m string +getDirName self + = liftIO + (({# call webkit_dom_html_input_element_get_dir_name #} + (toHTMLInputElement self)) + >>= + readUTFString) + +setDisabled :: + (MonadIO m, HTMLInputElementClass self) => self -> Bool -> m () +setDisabled self val + = liftIO + ({# call webkit_dom_html_input_element_set_disabled #} + (toHTMLInputElement self) + (fromBool val)) + +getDisabled :: + (MonadIO m, HTMLInputElementClass self) => self -> m Bool +getDisabled self + = liftIO + (toBool <$> + ({# call webkit_dom_html_input_element_get_disabled #} + (toHTMLInputElement self))) + +getForm :: + (MonadIO m, HTMLInputElementClass self) => + self -> m (Maybe HTMLFormElement) +getForm self + = liftIO + (maybeNull (makeNewGObject mkHTMLFormElement) + ({# call webkit_dom_html_input_element_get_form #} + (toHTMLInputElement self))) + +#if WEBKIT_CHECK_VERSION(2,2,2) +setFiles :: + (MonadIO m, FileListClass val, HTMLInputElementClass self) => + self -> Maybe val -> m () +setFiles self val + = liftIO + ({# call webkit_dom_html_input_element_set_files #} + (toHTMLInputElement self) + (maybe (FileList nullForeignPtr) toFileList val)) +#endif + +getFiles :: + (MonadIO m, HTMLInputElementClass self) => + self -> m (Maybe FileList) +getFiles self + = liftIO + (maybeNull (makeNewGObject mkFileList) + ({# call webkit_dom_html_input_element_get_files #} + (toHTMLInputElement self))) + +setFormAction :: + (MonadIO m, HTMLInputElementClass self, GlibString string) => + self -> string -> m () +setFormAction self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_input_element_set_form_action #} + (toHTMLInputElement self) + valPtr) + +getFormAction :: + (MonadIO m, HTMLInputElementClass self, GlibString string) => + self -> m string +getFormAction self + = liftIO + (({# call webkit_dom_html_input_element_get_form_action #} + (toHTMLInputElement self)) + >>= + readUTFString) + +setFormEnctype :: + (MonadIO m, HTMLInputElementClass self, GlibString string) => + self -> (Maybe string) -> m () +setFormEnctype self val + = liftIO + (maybeWith withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_input_element_set_form_enctype #} + (toHTMLInputElement self) + valPtr) + +getFormEnctype :: + (MonadIO m, HTMLInputElementClass self, GlibString string) => + self -> m (Maybe string) +getFormEnctype self + = liftIO + (({# call webkit_dom_html_input_element_get_form_enctype #} + (toHTMLInputElement self)) + >>= + maybePeek readUTFString) + +setFormMethod :: + (MonadIO m, HTMLInputElementClass self, GlibString string) => + self -> (Maybe string) -> m () +setFormMethod self val + = liftIO + (maybeWith withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_input_element_set_form_method #} + (toHTMLInputElement self) + valPtr) + +getFormMethod :: + (MonadIO m, HTMLInputElementClass self, GlibString string) => + self -> m (Maybe string) +getFormMethod self + = liftIO + (({# call webkit_dom_html_input_element_get_form_method #} + (toHTMLInputElement self)) + >>= + maybePeek readUTFString) + +setFormNoValidate :: + (MonadIO m, HTMLInputElementClass self) => self -> Bool -> m () +setFormNoValidate self val + = liftIO + ({# call webkit_dom_html_input_element_set_form_no_validate #} + (toHTMLInputElement self) + (fromBool val)) + +getFormNoValidate :: + (MonadIO m, HTMLInputElementClass self) => self -> m Bool +getFormNoValidate self + = liftIO + (toBool <$> + ({# call webkit_dom_html_input_element_get_form_no_validate #} + (toHTMLInputElement self))) + +setFormTarget :: + (MonadIO m, HTMLInputElementClass self, GlibString string) => + self -> string -> m () +setFormTarget self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_input_element_set_form_target #} + (toHTMLInputElement self) + valPtr) + +getFormTarget :: + (MonadIO m, HTMLInputElementClass self, GlibString string) => + self -> m string +getFormTarget self + = liftIO + (({# call webkit_dom_html_input_element_get_form_target #} + (toHTMLInputElement self)) + >>= + readUTFString) + +#if WEBKIT_CHECK_VERSION(2,2,2) +setHeight :: + (MonadIO m, HTMLInputElementClass self) => self -> Word -> m () +setHeight self val + = liftIO + ({# call webkit_dom_html_input_element_set_height #} + (toHTMLInputElement self) + (fromIntegral val)) + +getHeight :: + (MonadIO m, HTMLInputElementClass self) => self -> m Word +getHeight self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_input_element_get_height #} + (toHTMLInputElement self))) +#endif + +setIndeterminate :: + (MonadIO m, HTMLInputElementClass self) => self -> Bool -> m () +setIndeterminate self val + = liftIO + ({# call webkit_dom_html_input_element_set_indeterminate #} + (toHTMLInputElement self) + (fromBool val)) + +getIndeterminate :: + (MonadIO m, HTMLInputElementClass self) => self -> m Bool +getIndeterminate self + = liftIO + (toBool <$> + ({# call webkit_dom_html_input_element_get_indeterminate #} + (toHTMLInputElement self))) + +getList :: + (MonadIO m, HTMLInputElementClass self) => + self -> m (Maybe HTMLElement) +getList self + = liftIO + (maybeNull (makeNewGObject mkHTMLElement) + ({# call webkit_dom_html_input_element_get_list #} + (toHTMLInputElement self))) + +setMax :: + (MonadIO m, HTMLInputElementClass self, GlibString string) => + self -> string -> m () +setMax self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_input_element_set_max #} + (toHTMLInputElement self) + valPtr) + +getMax :: + (MonadIO m, HTMLInputElementClass self, GlibString string) => + self -> m string +getMax self + = liftIO + (({# call webkit_dom_html_input_element_get_max #} + (toHTMLInputElement self)) + >>= + readUTFString) + +setMaxLength :: + (MonadIO m, HTMLInputElementClass self) => self -> Int -> m () +setMaxLength self val + = liftIO + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_html_input_element_set_max_length #} + (toHTMLInputElement self) + (fromIntegral val) + errorPtr_) + +getMaxLength :: + (MonadIO m, HTMLInputElementClass self) => self -> m Int +getMaxLength self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_input_element_get_max_length #} + (toHTMLInputElement self))) + +setMin :: + (MonadIO m, HTMLInputElementClass self, GlibString string) => + self -> string -> m () +setMin self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_input_element_set_min #} + (toHTMLInputElement self) + valPtr) + +getMin :: + (MonadIO m, HTMLInputElementClass self, GlibString string) => + self -> m string +getMin self + = liftIO + (({# call webkit_dom_html_input_element_get_min #} + (toHTMLInputElement self)) + >>= + readUTFString) + +setMultiple :: + (MonadIO m, HTMLInputElementClass self) => self -> Bool -> m () +setMultiple self val + = liftIO + ({# call webkit_dom_html_input_element_set_multiple #} + (toHTMLInputElement self) + (fromBool val)) + +getMultiple :: + (MonadIO m, HTMLInputElementClass self) => self -> m Bool +getMultiple self + = liftIO + (toBool <$> + ({# call webkit_dom_html_input_element_get_multiple #} + (toHTMLInputElement self))) + +setName :: + (MonadIO m, HTMLInputElementClass self, GlibString string) => + self -> string -> m () +setName self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_input_element_set_name #} + (toHTMLInputElement self) + valPtr) + +getName :: + (MonadIO m, HTMLInputElementClass self, GlibString string) => + self -> m string +getName self + = liftIO + (({# call webkit_dom_html_input_element_get_name #} + (toHTMLInputElement self)) + >>= + readUTFString) + +setPattern :: + (MonadIO m, HTMLInputElementClass self, GlibString string) => + self -> string -> m () +setPattern self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_input_element_set_pattern #} + (toHTMLInputElement self) + valPtr) + +getPattern :: + (MonadIO m, HTMLInputElementClass self, GlibString string) => + self -> m string +getPattern self + = liftIO + (({# call webkit_dom_html_input_element_get_pattern #} + (toHTMLInputElement self)) + >>= + readUTFString) + +setPlaceholder :: + (MonadIO m, HTMLInputElementClass self, GlibString string) => + self -> string -> m () +setPlaceholder self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_input_element_set_placeholder #} + (toHTMLInputElement self) + valPtr) + +getPlaceholder :: + (MonadIO m, HTMLInputElementClass self, GlibString string) => + self -> m string +getPlaceholder self + = liftIO + (({# call webkit_dom_html_input_element_get_placeholder #} + (toHTMLInputElement self)) + >>= + readUTFString) + +setReadOnly :: + (MonadIO m, HTMLInputElementClass self) => self -> Bool -> m () +setReadOnly self val + = liftIO + ({# call webkit_dom_html_input_element_set_read_only #} + (toHTMLInputElement self) + (fromBool val)) + +getReadOnly :: + (MonadIO m, HTMLInputElementClass self) => self -> m Bool +getReadOnly self + = liftIO + (toBool <$> + ({# call webkit_dom_html_input_element_get_read_only #} + (toHTMLInputElement self))) + +setRequired :: + (MonadIO m, HTMLInputElementClass self) => self -> Bool -> m () +setRequired self val + = liftIO + ({# call webkit_dom_html_input_element_set_required #} + (toHTMLInputElement self) + (fromBool val)) + +getRequired :: + (MonadIO m, HTMLInputElementClass self) => self -> m Bool +getRequired self + = liftIO + (toBool <$> + ({# call webkit_dom_html_input_element_get_required #} + (toHTMLInputElement self))) + +#if WEBKIT_CHECK_VERSION(2,2,2) +setSize :: + (MonadIO m, HTMLInputElementClass self) => self -> Word -> m () +setSize self val + = liftIO + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_html_input_element_set_size #} + (toHTMLInputElement self) + (fromIntegral val) + errorPtr_) +#endif + +getSize :: + (MonadIO m, HTMLInputElementClass self) => self -> m Word +getSize self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_input_element_get_size #} + (toHTMLInputElement self))) + +setSrc :: + (MonadIO m, HTMLInputElementClass self, GlibString string) => + self -> string -> m () +setSrc self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_input_element_set_src #} + (toHTMLInputElement self) + valPtr) + +getSrc :: + (MonadIO m, HTMLInputElementClass self, GlibString string) => + self -> m string +getSrc self + = liftIO + (({# call webkit_dom_html_input_element_get_src #} + (toHTMLInputElement self)) + >>= + readUTFString) + +setStep :: + (MonadIO m, HTMLInputElementClass self, GlibString string) => + self -> string -> m () +setStep self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_input_element_set_step #} + (toHTMLInputElement self) + valPtr) + +getStep :: + (MonadIO m, HTMLInputElementClass self, GlibString string) => + self -> m string +getStep self + = liftIO + (({# call webkit_dom_html_input_element_get_step #} + (toHTMLInputElement self)) + >>= + readUTFString) + +setDefaultValue :: + (MonadIO m, HTMLInputElementClass self, GlibString string) => + self -> (Maybe string) -> m () +setDefaultValue self val + = liftIO + (maybeWith withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_input_element_set_default_value #} + (toHTMLInputElement self) + valPtr) + +getDefaultValue :: + (MonadIO m, HTMLInputElementClass self, GlibString string) => + self -> m (Maybe string) +getDefaultValue self + = liftIO + (({# call webkit_dom_html_input_element_get_default_value #} + (toHTMLInputElement self)) + >>= + maybePeek readUTFString) + +setValue :: + (MonadIO m, HTMLInputElementClass self, GlibString string) => + self -> (Maybe string) -> m () +setValue self val + = liftIO + (maybeWith withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_input_element_set_value #} + (toHTMLInputElement self) + valPtr) + +getValue :: + (MonadIO m, HTMLInputElementClass self, GlibString string) => + self -> m (Maybe string) +getValue self + = liftIO + (({# call webkit_dom_html_input_element_get_value #} + (toHTMLInputElement self)) + >>= + maybePeek readUTFString) + +setValueAsNumber :: + (MonadIO m, HTMLInputElementClass self) => self -> Double -> m () +setValueAsNumber self val + = liftIO + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_html_input_element_set_value_as_number #} + (toHTMLInputElement self) + (realToFrac val) + errorPtr_) + +getValueAsNumber :: + (MonadIO m, HTMLInputElementClass self) => self -> m Double +getValueAsNumber self + = liftIO + (realToFrac <$> + ({# call webkit_dom_html_input_element_get_value_as_number #} + (toHTMLInputElement self))) + +#if WEBKIT_CHECK_VERSION(2,2,2) +setWidth :: + (MonadIO m, HTMLInputElementClass self) => self -> Word -> m () +setWidth self val + = liftIO + ({# call webkit_dom_html_input_element_set_width #} + (toHTMLInputElement self) + (fromIntegral val)) + +getWidth :: + (MonadIO m, HTMLInputElementClass self) => self -> m Word +getWidth self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_input_element_get_width #} + (toHTMLInputElement self))) +#endif + +getWillValidate :: + (MonadIO m, HTMLInputElementClass self) => self -> m Bool +getWillValidate self + = liftIO + (toBool <$> + ({# call webkit_dom_html_input_element_get_will_validate #} + (toHTMLInputElement self))) + +getValidity :: + (MonadIO m, HTMLInputElementClass self) => + self -> m (Maybe ValidityState) +getValidity self + = liftIO + (maybeNull (makeNewGObject mkValidityState) + ({# call webkit_dom_html_input_element_get_validity #} + (toHTMLInputElement self))) + +getValidationMessage :: + (MonadIO m, HTMLInputElementClass self, GlibString string) => + self -> m string +getValidationMessage self + = liftIO + (({# call webkit_dom_html_input_element_get_validation_message #} + (toHTMLInputElement self)) + >>= + readUTFString) + +getLabels :: + (MonadIO m, HTMLInputElementClass self) => + self -> m (Maybe NodeList) +getLabels self + = liftIO + (maybeNull (makeNewGObject mkNodeList) + ({# call webkit_dom_html_input_element_get_labels #} + (toHTMLInputElement self))) + +setAlign :: + (MonadIO m, HTMLInputElementClass self, GlibString string) => + self -> string -> m () +setAlign self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_input_element_set_align #} + (toHTMLInputElement self) + valPtr) + +getAlign :: + (MonadIO m, HTMLInputElementClass self, GlibString string) => + self -> m string +getAlign self + = liftIO + (({# call webkit_dom_html_input_element_get_align #} + (toHTMLInputElement self)) + >>= + readUTFString) + +setUseMap :: + (MonadIO m, HTMLInputElementClass self, GlibString string) => + self -> string -> m () +setUseMap self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_input_element_set_use_map #} + (toHTMLInputElement self) + valPtr) + +getUseMap :: + (MonadIO m, HTMLInputElementClass self, GlibString string) => + self -> m string +getUseMap self + = liftIO + (({# call webkit_dom_html_input_element_get_use_map #} + (toHTMLInputElement self)) + >>= + readUTFString) + +setIncremental :: + (MonadIO m, HTMLInputElementClass self) => self -> Bool -> m () +setIncremental self val + = liftIO + ({# call webkit_dom_html_input_element_set_incremental #} + (toHTMLInputElement self) + (fromBool val)) + +getIncremental :: + (MonadIO m, HTMLInputElementClass self) => self -> m Bool +getIncremental self + = liftIO + (toBool <$> + ({# call webkit_dom_html_input_element_get_incremental #} + (toHTMLInputElement self))) + +#if WEBKIT_CHECK_VERSION(2,4,0) +setAutocorrect :: + (MonadIO m, HTMLInputElementClass self) => self -> Bool -> m () +setAutocorrect self val + = liftIO + ({# call webkit_dom_html_input_element_set_autocorrect #} + (toHTMLInputElement self) + (fromBool val)) + +getAutocorrect :: + (MonadIO m, HTMLInputElementClass self) => self -> m Bool +getAutocorrect self + = liftIO + (toBool <$> + ({# call webkit_dom_html_input_element_get_autocorrect #} + (toHTMLInputElement self))) + +setAutocapitalize :: + (MonadIO m, HTMLInputElementClass self, GlibString string) => + self -> (Maybe string) -> m () +setAutocapitalize self val + = liftIO + (maybeWith withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_input_element_set_autocapitalize #} + (toHTMLInputElement self) + valPtr) + +getAutocapitalize :: + (MonadIO m, HTMLInputElementClass self, GlibString string) => + self -> m (Maybe string) +getAutocapitalize self + = liftIO + (({# call webkit_dom_html_input_element_get_autocapitalize #} + (toHTMLInputElement self)) + >>= + maybePeek readUTFString) +#endif + +#if WEBKIT_CHECK_VERSION(2,7,0) +setCapture :: + (MonadIO m, HTMLInputElementClass self) => self -> Bool -> m () +setCapture self val + = liftIO + ({# call webkit_dom_html_input_element_set_capture #} + (toHTMLInputElement self) + (fromBool val)) + +getCapture :: + (MonadIO m, HTMLInputElementClass self) => self -> m Bool +getCapture self + = liftIO + (toBool <$> + ({# call webkit_dom_html_input_element_get_capture #} + (toHTMLInputElement self))) #endif diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLKeygenElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLKeygenElement.chs --- a/Graphics/UI/Gtk/WebKit/DOM/HTMLKeygenElement.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLKeygenElement.chs @@ -1,150 +1,197 @@ -module Graphics.UI.Gtk.WebKit.DOM.HTMLKeygenElement - (htmlKeygenElementCheckValidity, - htmlKeygenElementSetCustomValidity, htmlKeygenElementSetAutofocus, - htmlKeygenElementGetAutofocus, htmlKeygenElementSetChallenge, - htmlKeygenElementGetChallenge, htmlKeygenElementSetDisabled, - htmlKeygenElementGetDisabled, htmlKeygenElementGetForm, - htmlKeygenElementSetKeytype, htmlKeygenElementGetKeytype, - htmlKeygenElementSetName, htmlKeygenElementGetName, - htmlKeygenElementGetWillValidate, htmlKeygenElementGetValidity, - htmlKeygenElementGetValidationMessage, htmlKeygenElementGetLabels, - HTMLKeygenElement, HTMLKeygenElementClass, castToHTMLKeygenElement, - gTypeHTMLKeygenElement, toHTMLKeygenElement) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.HTMLKeygenElement( +checkValidity, +setCustomValidity, +setAutofocus, +getAutofocus, +setChallenge, +getChallenge, +setDisabled, +getDisabled, +getForm, +setKeytype, +getKeytype, +setName, +getName, +getWillValidate, +getValidity, +getValidationMessage, +getLabels, +HTMLKeygenElement, +castToHTMLKeygenElement, +gTypeHTMLKeygenElement, +HTMLKeygenElementClass, +toHTMLKeygenElement, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -htmlKeygenElementCheckValidity :: - (HTMLKeygenElementClass self) => self -> IO Bool -htmlKeygenElementCheckValidity self - = toBool <$> - ({# call webkit_dom_html_keygen_element_check_validity #} - (toHTMLKeygenElement self)) +checkValidity :: + (MonadIO m, HTMLKeygenElementClass self) => self -> m Bool +checkValidity self + = liftIO + (toBool <$> + ({# call webkit_dom_html_keygen_element_check_validity #} + (toHTMLKeygenElement self))) -htmlKeygenElementSetCustomValidity :: - (HTMLKeygenElementClass self) => self -> String -> IO () -htmlKeygenElementSetCustomValidity self error - = withUTFString error $ - \ errorPtr -> - {# call webkit_dom_html_keygen_element_set_custom_validity #} - (toHTMLKeygenElement self) - errorPtr +setCustomValidity :: + (MonadIO m, HTMLKeygenElementClass self, GlibString string) => + self -> (Maybe string) -> m () +setCustomValidity self error + = liftIO + (maybeWith withUTFString error $ + \ errorPtr -> + {# call webkit_dom_html_keygen_element_set_custom_validity #} + (toHTMLKeygenElement self) + errorPtr) -htmlKeygenElementSetAutofocus :: - (HTMLKeygenElementClass self) => self -> Bool -> IO () -htmlKeygenElementSetAutofocus self val - = {# call webkit_dom_html_keygen_element_set_autofocus #} - (toHTMLKeygenElement self) - (fromBool val) +setAutofocus :: + (MonadIO m, HTMLKeygenElementClass self) => self -> Bool -> m () +setAutofocus self val + = liftIO + ({# call webkit_dom_html_keygen_element_set_autofocus #} + (toHTMLKeygenElement self) + (fromBool val)) -htmlKeygenElementGetAutofocus :: - (HTMLKeygenElementClass self) => self -> IO Bool -htmlKeygenElementGetAutofocus self - = toBool <$> - ({# call webkit_dom_html_keygen_element_get_autofocus #} - (toHTMLKeygenElement self)) +getAutofocus :: + (MonadIO m, HTMLKeygenElementClass self) => self -> m Bool +getAutofocus self + = liftIO + (toBool <$> + ({# call webkit_dom_html_keygen_element_get_autofocus #} + (toHTMLKeygenElement self))) -htmlKeygenElementSetChallenge :: - (HTMLKeygenElementClass self) => self -> String -> IO () -htmlKeygenElementSetChallenge self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_keygen_element_set_challenge #} - (toHTMLKeygenElement self) - valPtr +setChallenge :: + (MonadIO m, HTMLKeygenElementClass self, GlibString string) => + self -> string -> m () +setChallenge self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_keygen_element_set_challenge #} + (toHTMLKeygenElement self) + valPtr) -htmlKeygenElementGetChallenge :: - (HTMLKeygenElementClass self) => self -> IO String -htmlKeygenElementGetChallenge self - = ({# call webkit_dom_html_keygen_element_get_challenge #} - (toHTMLKeygenElement self)) - >>= - readUTFString +getChallenge :: + (MonadIO m, HTMLKeygenElementClass self, GlibString string) => + self -> m string +getChallenge self + = liftIO + (({# call webkit_dom_html_keygen_element_get_challenge #} + (toHTMLKeygenElement self)) + >>= + readUTFString) -htmlKeygenElementSetDisabled :: - (HTMLKeygenElementClass self) => self -> Bool -> IO () -htmlKeygenElementSetDisabled self val - = {# call webkit_dom_html_keygen_element_set_disabled #} - (toHTMLKeygenElement self) - (fromBool val) +setDisabled :: + (MonadIO m, HTMLKeygenElementClass self) => self -> Bool -> m () +setDisabled self val + = liftIO + ({# call webkit_dom_html_keygen_element_set_disabled #} + (toHTMLKeygenElement self) + (fromBool val)) -htmlKeygenElementGetDisabled :: - (HTMLKeygenElementClass self) => self -> IO Bool -htmlKeygenElementGetDisabled self - = toBool <$> - ({# call webkit_dom_html_keygen_element_get_disabled #} - (toHTMLKeygenElement self)) +getDisabled :: + (MonadIO m, HTMLKeygenElementClass self) => self -> m Bool +getDisabled self + = liftIO + (toBool <$> + ({# call webkit_dom_html_keygen_element_get_disabled #} + (toHTMLKeygenElement self))) -htmlKeygenElementGetForm :: - (HTMLKeygenElementClass self) => self -> IO (Maybe HTMLFormElement) -htmlKeygenElementGetForm self - = maybeNull (makeNewGObject mkHTMLFormElement) - ({# call webkit_dom_html_keygen_element_get_form #} - (toHTMLKeygenElement self)) +getForm :: + (MonadIO m, HTMLKeygenElementClass self) => + self -> m (Maybe HTMLFormElement) +getForm self + = liftIO + (maybeNull (makeNewGObject mkHTMLFormElement) + ({# call webkit_dom_html_keygen_element_get_form #} + (toHTMLKeygenElement self))) -htmlKeygenElementSetKeytype :: - (HTMLKeygenElementClass self) => self -> String -> IO () -htmlKeygenElementSetKeytype self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_keygen_element_set_keytype #} - (toHTMLKeygenElement self) - valPtr +setKeytype :: + (MonadIO m, HTMLKeygenElementClass self, GlibString string) => + self -> string -> m () +setKeytype self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_keygen_element_set_keytype #} + (toHTMLKeygenElement self) + valPtr) -htmlKeygenElementGetKeytype :: - (HTMLKeygenElementClass self) => self -> IO String -htmlKeygenElementGetKeytype self - = ({# call webkit_dom_html_keygen_element_get_keytype #} - (toHTMLKeygenElement self)) - >>= - readUTFString +getKeytype :: + (MonadIO m, HTMLKeygenElementClass self, GlibString string) => + self -> m string +getKeytype self + = liftIO + (({# call webkit_dom_html_keygen_element_get_keytype #} + (toHTMLKeygenElement self)) + >>= + readUTFString) -htmlKeygenElementSetName :: - (HTMLKeygenElementClass self) => self -> String -> IO () -htmlKeygenElementSetName self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_keygen_element_set_name #} - (toHTMLKeygenElement self) - valPtr +setName :: + (MonadIO m, HTMLKeygenElementClass self, GlibString string) => + self -> string -> m () +setName self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_keygen_element_set_name #} + (toHTMLKeygenElement self) + valPtr) -htmlKeygenElementGetName :: - (HTMLKeygenElementClass self) => self -> IO String -htmlKeygenElementGetName self - = ({# call webkit_dom_html_keygen_element_get_name #} - (toHTMLKeygenElement self)) - >>= - readUTFString +getName :: + (MonadIO m, HTMLKeygenElementClass self, GlibString string) => + self -> m string +getName self + = liftIO + (({# call webkit_dom_html_keygen_element_get_name #} + (toHTMLKeygenElement self)) + >>= + readUTFString) -htmlKeygenElementGetWillValidate :: - (HTMLKeygenElementClass self) => self -> IO Bool -htmlKeygenElementGetWillValidate self - = toBool <$> - ({# call webkit_dom_html_keygen_element_get_will_validate #} - (toHTMLKeygenElement self)) +getWillValidate :: + (MonadIO m, HTMLKeygenElementClass self) => self -> m Bool +getWillValidate self + = liftIO + (toBool <$> + ({# call webkit_dom_html_keygen_element_get_will_validate #} + (toHTMLKeygenElement self))) -htmlKeygenElementGetValidity :: - (HTMLKeygenElementClass self) => self -> IO (Maybe ValidityState) -htmlKeygenElementGetValidity self - = maybeNull (makeNewGObject mkValidityState) - ({# call webkit_dom_html_keygen_element_get_validity #} - (toHTMLKeygenElement self)) +getValidity :: + (MonadIO m, HTMLKeygenElementClass self) => + self -> m (Maybe ValidityState) +getValidity self + = liftIO + (maybeNull (makeNewGObject mkValidityState) + ({# call webkit_dom_html_keygen_element_get_validity #} + (toHTMLKeygenElement self))) -htmlKeygenElementGetValidationMessage :: - (HTMLKeygenElementClass self) => self -> IO String -htmlKeygenElementGetValidationMessage self - = ({# call webkit_dom_html_keygen_element_get_validation_message #} - (toHTMLKeygenElement self)) - >>= - readUTFString +getValidationMessage :: + (MonadIO m, HTMLKeygenElementClass self, GlibString string) => + self -> m string +getValidationMessage self + = liftIO + (({# call webkit_dom_html_keygen_element_get_validation_message #} + (toHTMLKeygenElement self)) + >>= + readUTFString) -htmlKeygenElementGetLabels :: - (HTMLKeygenElementClass self) => self -> IO (Maybe NodeList) -htmlKeygenElementGetLabels self - = maybeNull (makeNewGObject mkNodeList) - ({# call webkit_dom_html_keygen_element_get_labels #} - (toHTMLKeygenElement self)) +getLabels :: + (MonadIO m, HTMLKeygenElementClass self) => + self -> m (Maybe NodeList) +getLabels self + = liftIO + (maybeNull (makeNewGObject mkNodeList) + ({# call webkit_dom_html_keygen_element_get_labels #} + (toHTMLKeygenElement self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLLIElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLLIElement.chs --- a/Graphics/UI/Gtk/WebKit/DOM/HTMLLIElement.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLLIElement.chs @@ -1,25 +1,38 @@ -module Graphics.UI.Gtk.WebKit.DOM.HTMLLIElement - (htmlliElementSetValue, htmlliElementGetValue, HTMLLIElement, - HTMLLIElementClass, castToHTMLLIElement, gTypeHTMLLIElement, - toHTMLLIElement) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.HTMLLIElement( +setValue, +getValue, +HTMLLIElement, +castToHTMLLIElement, +gTypeHTMLLIElement, +HTMLLIElementClass, +toHTMLLIElement, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -htmlliElementSetValue :: - (HTMLLIElementClass self) => self -> Int -> IO () -htmlliElementSetValue self val - = {# call webkit_dom_htmlli_element_set_value #} - (toHTMLLIElement self) - (fromIntegral val) +setValue :: + (MonadIO m, HTMLLIElementClass self) => self -> Int -> m () +setValue self val + = liftIO + ({# call webkit_dom_htmlli_element_set_value #} + (toHTMLLIElement self) + (fromIntegral val)) -htmlliElementGetValue :: - (HTMLLIElementClass self) => self -> IO Int -htmlliElementGetValue self - = fromIntegral <$> - ({# call webkit_dom_htmlli_element_get_value #} - (toHTMLLIElement self)) +getValue :: (MonadIO m, HTMLLIElementClass self) => self -> m Int +getValue self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_htmlli_element_get_value #} + (toHTMLLIElement self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLLabelElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLLabelElement.chs --- a/Graphics/UI/Gtk/WebKit/DOM/HTMLLabelElement.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLLabelElement.chs @@ -1,43 +1,64 @@ -module Graphics.UI.Gtk.WebKit.DOM.HTMLLabelElement - (htmlLabelElementGetForm, htmlLabelElementSetHtmlFor, - htmlLabelElementGetHtmlFor, htmlLabelElementGetControl, - HTMLLabelElement, HTMLLabelElementClass, castToHTMLLabelElement, - gTypeHTMLLabelElement, toHTMLLabelElement) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.HTMLLabelElement( +getForm, +setHtmlFor, +getHtmlFor, +getControl, +HTMLLabelElement, +castToHTMLLabelElement, +gTypeHTMLLabelElement, +HTMLLabelElementClass, +toHTMLLabelElement, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -htmlLabelElementGetForm :: - (HTMLLabelElementClass self) => self -> IO (Maybe HTMLFormElement) -htmlLabelElementGetForm self - = maybeNull (makeNewGObject mkHTMLFormElement) - ({# call webkit_dom_html_label_element_get_form #} - (toHTMLLabelElement self)) +getForm :: + (MonadIO m, HTMLLabelElementClass self) => + self -> m (Maybe HTMLFormElement) +getForm self + = liftIO + (maybeNull (makeNewGObject mkHTMLFormElement) + ({# call webkit_dom_html_label_element_get_form #} + (toHTMLLabelElement self))) -htmlLabelElementSetHtmlFor :: - (HTMLLabelElementClass self) => self -> String -> IO () -htmlLabelElementSetHtmlFor self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_label_element_set_html_for #} - (toHTMLLabelElement self) - valPtr +setHtmlFor :: + (MonadIO m, HTMLLabelElementClass self, GlibString string) => + self -> string -> m () +setHtmlFor self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_label_element_set_html_for #} + (toHTMLLabelElement self) + valPtr) -htmlLabelElementGetHtmlFor :: - (HTMLLabelElementClass self) => self -> IO String -htmlLabelElementGetHtmlFor self - = ({# call webkit_dom_html_label_element_get_html_for #} - (toHTMLLabelElement self)) - >>= - readUTFString +getHtmlFor :: + (MonadIO m, HTMLLabelElementClass self, GlibString string) => + self -> m string +getHtmlFor self + = liftIO + (({# call webkit_dom_html_label_element_get_html_for #} + (toHTMLLabelElement self)) + >>= + readUTFString) -htmlLabelElementGetControl :: - (HTMLLabelElementClass self) => self -> IO (Maybe HTMLElement) -htmlLabelElementGetControl self - = maybeNull (makeNewGObject mkHTMLElement) - ({# call webkit_dom_html_label_element_get_control #} - (toHTMLLabelElement self)) +getControl :: + (MonadIO m, HTMLLabelElementClass self) => + self -> m (Maybe HTMLElement) +getControl self + = liftIO + (maybeNull (makeNewGObject mkHTMLElement) + ({# call webkit_dom_html_label_element_get_control #} + (toHTMLLabelElement self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLLegendElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLLegendElement.chs --- a/Graphics/UI/Gtk/WebKit/DOM/HTMLLegendElement.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLLegendElement.chs @@ -1,36 +1,54 @@ -module Graphics.UI.Gtk.WebKit.DOM.HTMLLegendElement - (htmlLegendElementGetForm, htmlLegendElementSetAlign, - htmlLegendElementGetAlign, HTMLLegendElement, - HTMLLegendElementClass, castToHTMLLegendElement, - gTypeHTMLLegendElement, toHTMLLegendElement) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.HTMLLegendElement( +getForm, +setAlign, +getAlign, +HTMLLegendElement, +castToHTMLLegendElement, +gTypeHTMLLegendElement, +HTMLLegendElementClass, +toHTMLLegendElement, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -htmlLegendElementGetForm :: - (HTMLLegendElementClass self) => self -> IO (Maybe HTMLFormElement) -htmlLegendElementGetForm self - = maybeNull (makeNewGObject mkHTMLFormElement) - ({# call webkit_dom_html_legend_element_get_form #} - (toHTMLLegendElement self)) +getForm :: + (MonadIO m, HTMLLegendElementClass self) => + self -> m (Maybe HTMLFormElement) +getForm self + = liftIO + (maybeNull (makeNewGObject mkHTMLFormElement) + ({# call webkit_dom_html_legend_element_get_form #} + (toHTMLLegendElement self))) -htmlLegendElementSetAlign :: - (HTMLLegendElementClass self) => self -> String -> IO () -htmlLegendElementSetAlign self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_legend_element_set_align #} - (toHTMLLegendElement self) - valPtr +setAlign :: + (MonadIO m, HTMLLegendElementClass self, GlibString string) => + self -> string -> m () +setAlign self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_legend_element_set_align #} + (toHTMLLegendElement self) + valPtr) -htmlLegendElementGetAlign :: - (HTMLLegendElementClass self) => self -> IO String -htmlLegendElementGetAlign self - = ({# call webkit_dom_html_legend_element_get_align #} - (toHTMLLegendElement self)) - >>= - readUTFString +getAlign :: + (MonadIO m, HTMLLegendElementClass self, GlibString string) => + self -> m string +getAlign self + = liftIO + (({# call webkit_dom_html_legend_element_get_align #} + (toHTMLLegendElement self)) + >>= + readUTFString) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLLinkElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLLinkElement.chs --- a/Graphics/UI/Gtk/WebKit/DOM/HTMLLinkElement.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLLinkElement.chs @@ -1,158 +1,224 @@ -module Graphics.UI.Gtk.WebKit.DOM.HTMLLinkElement - (htmlLinkElementSetDisabled, htmlLinkElementGetDisabled, - htmlLinkElementSetCharset, htmlLinkElementGetCharset, - htmlLinkElementSetHref, htmlLinkElementGetHref, - htmlLinkElementSetHreflang, htmlLinkElementGetHreflang, - htmlLinkElementSetMedia, htmlLinkElementGetMedia, - htmlLinkElementSetRel, htmlLinkElementGetRel, - htmlLinkElementSetRev, htmlLinkElementGetRev, - htmlLinkElementSetTarget, htmlLinkElementGetTarget, - htmlLinkElementGetSheet, HTMLLinkElement, HTMLLinkElementClass, - castToHTMLLinkElement, gTypeHTMLLinkElement, toHTMLLinkElement) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.HTMLLinkElement( +setDisabled, +getDisabled, +setCharset, +getCharset, +setHref, +getHref, +setHreflang, +getHreflang, +setMedia, +getMedia, +setRel, +getRel, +setRev, +getRev, +setTarget, +getTarget, +getSheet, +#if WEBKIT_CHECK_VERSION(99,0,0) +getRelList, +#endif +HTMLLinkElement, +castToHTMLLinkElement, +gTypeHTMLLinkElement, +HTMLLinkElementClass, +toHTMLLinkElement, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -htmlLinkElementSetDisabled :: - (HTMLLinkElementClass self) => self -> Bool -> IO () -htmlLinkElementSetDisabled self val - = {# call webkit_dom_html_link_element_set_disabled #} - (toHTMLLinkElement self) - (fromBool val) +setDisabled :: + (MonadIO m, HTMLLinkElementClass self) => self -> Bool -> m () +setDisabled self val + = liftIO + ({# call webkit_dom_html_link_element_set_disabled #} + (toHTMLLinkElement self) + (fromBool val)) -htmlLinkElementGetDisabled :: - (HTMLLinkElementClass self) => self -> IO Bool -htmlLinkElementGetDisabled self - = toBool <$> - ({# call webkit_dom_html_link_element_get_disabled #} - (toHTMLLinkElement self)) +getDisabled :: + (MonadIO m, HTMLLinkElementClass self) => self -> m Bool +getDisabled self + = liftIO + (toBool <$> + ({# call webkit_dom_html_link_element_get_disabled #} + (toHTMLLinkElement self))) -htmlLinkElementSetCharset :: - (HTMLLinkElementClass self) => self -> String -> IO () -htmlLinkElementSetCharset self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_link_element_set_charset #} - (toHTMLLinkElement self) - valPtr +setCharset :: + (MonadIO m, HTMLLinkElementClass self, GlibString string) => + self -> string -> m () +setCharset self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_link_element_set_charset #} + (toHTMLLinkElement self) + valPtr) -htmlLinkElementGetCharset :: - (HTMLLinkElementClass self) => self -> IO String -htmlLinkElementGetCharset self - = ({# call webkit_dom_html_link_element_get_charset #} - (toHTMLLinkElement self)) - >>= - readUTFString +getCharset :: + (MonadIO m, HTMLLinkElementClass self, GlibString string) => + self -> m string +getCharset self + = liftIO + (({# call webkit_dom_html_link_element_get_charset #} + (toHTMLLinkElement self)) + >>= + readUTFString) -htmlLinkElementSetHref :: - (HTMLLinkElementClass self) => self -> String -> IO () -htmlLinkElementSetHref self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_link_element_set_href #} - (toHTMLLinkElement self) - valPtr +setHref :: + (MonadIO m, HTMLLinkElementClass self, GlibString string) => + self -> string -> m () +setHref self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_link_element_set_href #} + (toHTMLLinkElement self) + valPtr) -htmlLinkElementGetHref :: - (HTMLLinkElementClass self) => self -> IO String -htmlLinkElementGetHref self - = ({# call webkit_dom_html_link_element_get_href #} - (toHTMLLinkElement self)) - >>= - readUTFString +getHref :: + (MonadIO m, HTMLLinkElementClass self, GlibString string) => + self -> m string +getHref self + = liftIO + (({# call webkit_dom_html_link_element_get_href #} + (toHTMLLinkElement self)) + >>= + readUTFString) -htmlLinkElementSetHreflang :: - (HTMLLinkElementClass self) => self -> String -> IO () -htmlLinkElementSetHreflang self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_link_element_set_hreflang #} - (toHTMLLinkElement self) - valPtr +setHreflang :: + (MonadIO m, HTMLLinkElementClass self, GlibString string) => + self -> string -> m () +setHreflang self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_link_element_set_hreflang #} + (toHTMLLinkElement self) + valPtr) -htmlLinkElementGetHreflang :: - (HTMLLinkElementClass self) => self -> IO String -htmlLinkElementGetHreflang self - = ({# call webkit_dom_html_link_element_get_hreflang #} - (toHTMLLinkElement self)) - >>= - readUTFString +getHreflang :: + (MonadIO m, HTMLLinkElementClass self, GlibString string) => + self -> m string +getHreflang self + = liftIO + (({# call webkit_dom_html_link_element_get_hreflang #} + (toHTMLLinkElement self)) + >>= + readUTFString) -htmlLinkElementSetMedia :: - (HTMLLinkElementClass self) => self -> String -> IO () -htmlLinkElementSetMedia self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_link_element_set_media #} - (toHTMLLinkElement self) - valPtr +setMedia :: + (MonadIO m, HTMLLinkElementClass self, GlibString string) => + self -> string -> m () +setMedia self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_link_element_set_media #} + (toHTMLLinkElement self) + valPtr) -htmlLinkElementGetMedia :: - (HTMLLinkElementClass self) => self -> IO String -htmlLinkElementGetMedia self - = ({# call webkit_dom_html_link_element_get_media #} - (toHTMLLinkElement self)) - >>= - readUTFString +getMedia :: + (MonadIO m, HTMLLinkElementClass self, GlibString string) => + self -> m string +getMedia self + = liftIO + (({# call webkit_dom_html_link_element_get_media #} + (toHTMLLinkElement self)) + >>= + readUTFString) -htmlLinkElementSetRel :: - (HTMLLinkElementClass self) => self -> String -> IO () -htmlLinkElementSetRel self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_link_element_set_rel #} - (toHTMLLinkElement self) - valPtr +setRel :: + (MonadIO m, HTMLLinkElementClass self, GlibString string) => + self -> string -> m () +setRel self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_link_element_set_rel #} + (toHTMLLinkElement self) + valPtr) -htmlLinkElementGetRel :: - (HTMLLinkElementClass self) => self -> IO String -htmlLinkElementGetRel self - = ({# call webkit_dom_html_link_element_get_rel #} - (toHTMLLinkElement self)) - >>= - readUTFString +getRel :: + (MonadIO m, HTMLLinkElementClass self, GlibString string) => + self -> m string +getRel self + = liftIO + (({# call webkit_dom_html_link_element_get_rel #} + (toHTMLLinkElement self)) + >>= + readUTFString) -htmlLinkElementSetRev :: - (HTMLLinkElementClass self) => self -> String -> IO () -htmlLinkElementSetRev self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_link_element_set_rev #} - (toHTMLLinkElement self) - valPtr +setRev :: + (MonadIO m, HTMLLinkElementClass self, GlibString string) => + self -> string -> m () +setRev self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_link_element_set_rev #} + (toHTMLLinkElement self) + valPtr) -htmlLinkElementGetRev :: - (HTMLLinkElementClass self) => self -> IO String -htmlLinkElementGetRev self - = ({# call webkit_dom_html_link_element_get_rev #} - (toHTMLLinkElement self)) - >>= - readUTFString +getRev :: + (MonadIO m, HTMLLinkElementClass self, GlibString string) => + self -> m string +getRev self + = liftIO + (({# call webkit_dom_html_link_element_get_rev #} + (toHTMLLinkElement self)) + >>= + readUTFString) -htmlLinkElementSetTarget :: - (HTMLLinkElementClass self) => self -> String -> IO () -htmlLinkElementSetTarget self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_link_element_set_target #} - (toHTMLLinkElement self) - valPtr +setTarget :: + (MonadIO m, HTMLLinkElementClass self, GlibString string) => + self -> string -> m () +setTarget self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_link_element_set_target #} + (toHTMLLinkElement self) + valPtr) -htmlLinkElementGetTarget :: - (HTMLLinkElementClass self) => self -> IO String -htmlLinkElementGetTarget self - = ({# call webkit_dom_html_link_element_get_target #} - (toHTMLLinkElement self)) - >>= - readUTFString +getTarget :: + (MonadIO m, HTMLLinkElementClass self, GlibString string) => + self -> m string +getTarget self + = liftIO + (({# call webkit_dom_html_link_element_get_target #} + (toHTMLLinkElement self)) + >>= + readUTFString) -htmlLinkElementGetSheet :: - (HTMLLinkElementClass self) => self -> IO (Maybe StyleSheet) -htmlLinkElementGetSheet self - = maybeNull (makeNewGObject mkStyleSheet) - ({# call webkit_dom_html_link_element_get_sheet #} - (toHTMLLinkElement self)) +getSheet :: + (MonadIO m, HTMLLinkElementClass self) => + self -> m (Maybe StyleSheet) +getSheet self + = liftIO + (maybeNull (makeNewGObject mkStyleSheet) + ({# call webkit_dom_html_link_element_get_sheet #} + (toHTMLLinkElement self))) + +#if WEBKIT_CHECK_VERSION(99,0,0) +getRelList :: + (MonadIO m, HTMLLinkElementClass self) => + self -> m (Maybe DOMTokenList) +getRelList self + = liftIO + (maybeNull (makeNewGObject mkDOMTokenList) + ({# call webkit_dom_html_link_element_get_rel_list #} + (toHTMLLinkElement self))) +#endif diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLMapElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLMapElement.chs --- a/Graphics/UI/Gtk/WebKit/DOM/HTMLMapElement.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLMapElement.chs @@ -1,35 +1,54 @@ -module Graphics.UI.Gtk.WebKit.DOM.HTMLMapElement - (htmlMapElementGetAreas, htmlMapElementSetName, - htmlMapElementGetName, HTMLMapElement, HTMLMapElementClass, - castToHTMLMapElement, gTypeHTMLMapElement, toHTMLMapElement) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.HTMLMapElement( +getAreas, +setName, +getName, +HTMLMapElement, +castToHTMLMapElement, +gTypeHTMLMapElement, +HTMLMapElementClass, +toHTMLMapElement, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -htmlMapElementGetAreas :: - (HTMLMapElementClass self) => self -> IO (Maybe HTMLCollection) -htmlMapElementGetAreas self - = maybeNull (makeNewGObject mkHTMLCollection) - ({# call webkit_dom_html_map_element_get_areas #} - (toHTMLMapElement self)) +getAreas :: + (MonadIO m, HTMLMapElementClass self) => + self -> m (Maybe HTMLCollection) +getAreas self + = liftIO + (maybeNull (makeNewGObject mkHTMLCollection) + ({# call webkit_dom_html_map_element_get_areas #} + (toHTMLMapElement self))) -htmlMapElementSetName :: - (HTMLMapElementClass self) => self -> String -> IO () -htmlMapElementSetName self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_map_element_set_name #} - (toHTMLMapElement self) - valPtr +setName :: + (MonadIO m, HTMLMapElementClass self, GlibString string) => + self -> string -> m () +setName self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_map_element_set_name #} + (toHTMLMapElement self) + valPtr) -htmlMapElementGetName :: - (HTMLMapElementClass self) => self -> IO String -htmlMapElementGetName self - = ({# call webkit_dom_html_map_element_get_name #} - (toHTMLMapElement self)) - >>= - readUTFString +getName :: + (MonadIO m, HTMLMapElementClass self, GlibString string) => + self -> m string +getName self + = liftIO + (({# call webkit_dom_html_map_element_get_name #} + (toHTMLMapElement self)) + >>= + readUTFString) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLMarqueeElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLMarqueeElement.chs --- a/Graphics/UI/Gtk/WebKit/DOM/HTMLMarqueeElement.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLMarqueeElement.chs @@ -1,214 +1,267 @@ -module Graphics.UI.Gtk.WebKit.DOM.HTMLMarqueeElement - (htmlMarqueeElementStart, htmlMarqueeElementStop, - htmlMarqueeElementSetBehavior, htmlMarqueeElementGetBehavior, - htmlMarqueeElementSetBgColor, htmlMarqueeElementGetBgColor, - htmlMarqueeElementSetDirection, htmlMarqueeElementGetDirection, - htmlMarqueeElementSetHeight, htmlMarqueeElementGetHeight, - htmlMarqueeElementSetHspace, htmlMarqueeElementGetHspace, - htmlMarqueeElementSetLoop, htmlMarqueeElementGetLoop, - htmlMarqueeElementSetScrollAmount, - htmlMarqueeElementGetScrollAmount, - htmlMarqueeElementSetScrollDelay, htmlMarqueeElementGetScrollDelay, - htmlMarqueeElementSetTrueSpeed, htmlMarqueeElementGetTrueSpeed, - htmlMarqueeElementSetVspace, htmlMarqueeElementGetVspace, - htmlMarqueeElementSetWidth, htmlMarqueeElementGetWidth, - HTMLMarqueeElement, HTMLMarqueeElementClass, - castToHTMLMarqueeElement, gTypeHTMLMarqueeElement, - toHTMLMarqueeElement) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.HTMLMarqueeElement( +start, +stop, +setBehavior, +getBehavior, +setBgColor, +getBgColor, +setDirection, +getDirection, +setHeight, +getHeight, +setHspace, +getHspace, +setLoop, +getLoop, +setScrollAmount, +getScrollAmount, +setScrollDelay, +getScrollDelay, +setTrueSpeed, +getTrueSpeed, +setVspace, +getVspace, +setWidth, +getWidth, +HTMLMarqueeElement, +castToHTMLMarqueeElement, +gTypeHTMLMarqueeElement, +HTMLMarqueeElementClass, +toHTMLMarqueeElement, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -htmlMarqueeElementStart :: - (HTMLMarqueeElementClass self) => self -> IO () -htmlMarqueeElementStart self - = {# call webkit_dom_html_marquee_element_start #} - (toHTMLMarqueeElement self) +start :: (MonadIO m, HTMLMarqueeElementClass self) => self -> m () +start self + = liftIO + ({# call webkit_dom_html_marquee_element_start #} + (toHTMLMarqueeElement self)) -htmlMarqueeElementStop :: - (HTMLMarqueeElementClass self) => self -> IO () -htmlMarqueeElementStop self - = {# call webkit_dom_html_marquee_element_stop #} - (toHTMLMarqueeElement self) +stop :: (MonadIO m, HTMLMarqueeElementClass self) => self -> m () +stop self + = liftIO + ({# call webkit_dom_html_marquee_element_stop #} + (toHTMLMarqueeElement self)) -htmlMarqueeElementSetBehavior :: - (HTMLMarqueeElementClass self) => self -> String -> IO () -htmlMarqueeElementSetBehavior self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_marquee_element_set_behavior #} - (toHTMLMarqueeElement self) - valPtr +setBehavior :: + (MonadIO m, HTMLMarqueeElementClass self, GlibString string) => + self -> string -> m () +setBehavior self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_marquee_element_set_behavior #} + (toHTMLMarqueeElement self) + valPtr) -htmlMarqueeElementGetBehavior :: - (HTMLMarqueeElementClass self) => self -> IO String -htmlMarqueeElementGetBehavior self - = ({# call webkit_dom_html_marquee_element_get_behavior #} - (toHTMLMarqueeElement self)) - >>= - readUTFString +getBehavior :: + (MonadIO m, HTMLMarqueeElementClass self, GlibString string) => + self -> m string +getBehavior self + = liftIO + (({# call webkit_dom_html_marquee_element_get_behavior #} + (toHTMLMarqueeElement self)) + >>= + readUTFString) -htmlMarqueeElementSetBgColor :: - (HTMLMarqueeElementClass self) => self -> String -> IO () -htmlMarqueeElementSetBgColor self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_marquee_element_set_bg_color #} - (toHTMLMarqueeElement self) - valPtr +setBgColor :: + (MonadIO m, HTMLMarqueeElementClass self, GlibString string) => + self -> string -> m () +setBgColor self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_marquee_element_set_bg_color #} + (toHTMLMarqueeElement self) + valPtr) -htmlMarqueeElementGetBgColor :: - (HTMLMarqueeElementClass self) => self -> IO String -htmlMarqueeElementGetBgColor self - = ({# call webkit_dom_html_marquee_element_get_bg_color #} - (toHTMLMarqueeElement self)) - >>= - readUTFString +getBgColor :: + (MonadIO m, HTMLMarqueeElementClass self, GlibString string) => + self -> m string +getBgColor self + = liftIO + (({# call webkit_dom_html_marquee_element_get_bg_color #} + (toHTMLMarqueeElement self)) + >>= + readUTFString) -htmlMarqueeElementSetDirection :: - (HTMLMarqueeElementClass self) => self -> String -> IO () -htmlMarqueeElementSetDirection self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_marquee_element_set_direction #} - (toHTMLMarqueeElement self) - valPtr +setDirection :: + (MonadIO m, HTMLMarqueeElementClass self, GlibString string) => + self -> string -> m () +setDirection self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_marquee_element_set_direction #} + (toHTMLMarqueeElement self) + valPtr) -htmlMarqueeElementGetDirection :: - (HTMLMarqueeElementClass self) => self -> IO String -htmlMarqueeElementGetDirection self - = ({# call webkit_dom_html_marquee_element_get_direction #} - (toHTMLMarqueeElement self)) - >>= - readUTFString +getDirection :: + (MonadIO m, HTMLMarqueeElementClass self, GlibString string) => + self -> m string +getDirection self + = liftIO + (({# call webkit_dom_html_marquee_element_get_direction #} + (toHTMLMarqueeElement self)) + >>= + readUTFString) -htmlMarqueeElementSetHeight :: - (HTMLMarqueeElementClass self) => self -> String -> IO () -htmlMarqueeElementSetHeight self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_marquee_element_set_height #} - (toHTMLMarqueeElement self) - valPtr +setHeight :: + (MonadIO m, HTMLMarqueeElementClass self, GlibString string) => + self -> string -> m () +setHeight self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_marquee_element_set_height #} + (toHTMLMarqueeElement self) + valPtr) -htmlMarqueeElementGetHeight :: - (HTMLMarqueeElementClass self) => self -> IO String -htmlMarqueeElementGetHeight self - = ({# call webkit_dom_html_marquee_element_get_height #} - (toHTMLMarqueeElement self)) - >>= - readUTFString +getHeight :: + (MonadIO m, HTMLMarqueeElementClass self, GlibString string) => + self -> m string +getHeight self + = liftIO + (({# call webkit_dom_html_marquee_element_get_height #} + (toHTMLMarqueeElement self)) + >>= + readUTFString) -htmlMarqueeElementSetHspace :: - (HTMLMarqueeElementClass self) => self -> Word -> IO () -htmlMarqueeElementSetHspace self val - = {# call webkit_dom_html_marquee_element_set_hspace #} - (toHTMLMarqueeElement self) - (fromIntegral val) +setHspace :: + (MonadIO m, HTMLMarqueeElementClass self) => self -> Word -> m () +setHspace self val + = liftIO + ({# call webkit_dom_html_marquee_element_set_hspace #} + (toHTMLMarqueeElement self) + (fromIntegral val)) -htmlMarqueeElementGetHspace :: - (HTMLMarqueeElementClass self) => self -> IO Word -htmlMarqueeElementGetHspace self - = fromIntegral <$> - ({# call webkit_dom_html_marquee_element_get_hspace #} - (toHTMLMarqueeElement self)) +getHspace :: + (MonadIO m, HTMLMarqueeElementClass self) => self -> m Word +getHspace self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_marquee_element_get_hspace #} + (toHTMLMarqueeElement self))) -htmlMarqueeElementSetLoop :: - (HTMLMarqueeElementClass self) => self -> Int -> IO () -htmlMarqueeElementSetLoop self val - = propagateGError $ - \ errorPtr_ -> - {# call webkit_dom_html_marquee_element_set_loop #} - (toHTMLMarqueeElement self) - (fromIntegral val) - errorPtr_ +setLoop :: + (MonadIO m, HTMLMarqueeElementClass self) => self -> Int -> m () +setLoop self val + = liftIO + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_html_marquee_element_set_loop #} + (toHTMLMarqueeElement self) + (fromIntegral val) + errorPtr_) -htmlMarqueeElementGetLoop :: - (HTMLMarqueeElementClass self) => self -> IO Int -htmlMarqueeElementGetLoop self - = fromIntegral <$> - ({# call webkit_dom_html_marquee_element_get_loop #} - (toHTMLMarqueeElement self)) +getLoop :: + (MonadIO m, HTMLMarqueeElementClass self) => self -> m Int +getLoop self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_marquee_element_get_loop #} + (toHTMLMarqueeElement self))) -htmlMarqueeElementSetScrollAmount :: - (HTMLMarqueeElementClass self) => self -> Int -> IO () -htmlMarqueeElementSetScrollAmount self val - = propagateGError $ - \ errorPtr_ -> - {# call webkit_dom_html_marquee_element_set_scroll_amount #} - (toHTMLMarqueeElement self) - (fromIntegral val) - errorPtr_ +setScrollAmount :: + (MonadIO m, HTMLMarqueeElementClass self) => self -> Int -> m () +setScrollAmount self val + = liftIO + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_html_marquee_element_set_scroll_amount #} + (toHTMLMarqueeElement self) + (fromIntegral val) + errorPtr_) -htmlMarqueeElementGetScrollAmount :: - (HTMLMarqueeElementClass self) => self -> IO Int -htmlMarqueeElementGetScrollAmount self - = fromIntegral <$> - ({# call webkit_dom_html_marquee_element_get_scroll_amount #} - (toHTMLMarqueeElement self)) +getScrollAmount :: + (MonadIO m, HTMLMarqueeElementClass self) => self -> m Int +getScrollAmount self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_marquee_element_get_scroll_amount #} + (toHTMLMarqueeElement self))) -htmlMarqueeElementSetScrollDelay :: - (HTMLMarqueeElementClass self) => self -> Int -> IO () -htmlMarqueeElementSetScrollDelay self val - = propagateGError $ - \ errorPtr_ -> - {# call webkit_dom_html_marquee_element_set_scroll_delay #} - (toHTMLMarqueeElement self) - (fromIntegral val) - errorPtr_ +setScrollDelay :: + (MonadIO m, HTMLMarqueeElementClass self) => self -> Int -> m () +setScrollDelay self val + = liftIO + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_html_marquee_element_set_scroll_delay #} + (toHTMLMarqueeElement self) + (fromIntegral val) + errorPtr_) -htmlMarqueeElementGetScrollDelay :: - (HTMLMarqueeElementClass self) => self -> IO Int -htmlMarqueeElementGetScrollDelay self - = fromIntegral <$> - ({# call webkit_dom_html_marquee_element_get_scroll_delay #} - (toHTMLMarqueeElement self)) +getScrollDelay :: + (MonadIO m, HTMLMarqueeElementClass self) => self -> m Int +getScrollDelay self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_marquee_element_get_scroll_delay #} + (toHTMLMarqueeElement self))) -htmlMarqueeElementSetTrueSpeed :: - (HTMLMarqueeElementClass self) => self -> Bool -> IO () -htmlMarqueeElementSetTrueSpeed self val - = {# call webkit_dom_html_marquee_element_set_true_speed #} - (toHTMLMarqueeElement self) - (fromBool val) +setTrueSpeed :: + (MonadIO m, HTMLMarqueeElementClass self) => self -> Bool -> m () +setTrueSpeed self val + = liftIO + ({# call webkit_dom_html_marquee_element_set_true_speed #} + (toHTMLMarqueeElement self) + (fromBool val)) -htmlMarqueeElementGetTrueSpeed :: - (HTMLMarqueeElementClass self) => self -> IO Bool -htmlMarqueeElementGetTrueSpeed self - = toBool <$> - ({# call webkit_dom_html_marquee_element_get_true_speed #} - (toHTMLMarqueeElement self)) +getTrueSpeed :: + (MonadIO m, HTMLMarqueeElementClass self) => self -> m Bool +getTrueSpeed self + = liftIO + (toBool <$> + ({# call webkit_dom_html_marquee_element_get_true_speed #} + (toHTMLMarqueeElement self))) -htmlMarqueeElementSetVspace :: - (HTMLMarqueeElementClass self) => self -> Word -> IO () -htmlMarqueeElementSetVspace self val - = {# call webkit_dom_html_marquee_element_set_vspace #} - (toHTMLMarqueeElement self) - (fromIntegral val) +setVspace :: + (MonadIO m, HTMLMarqueeElementClass self) => self -> Word -> m () +setVspace self val + = liftIO + ({# call webkit_dom_html_marquee_element_set_vspace #} + (toHTMLMarqueeElement self) + (fromIntegral val)) -htmlMarqueeElementGetVspace :: - (HTMLMarqueeElementClass self) => self -> IO Word -htmlMarqueeElementGetVspace self - = fromIntegral <$> - ({# call webkit_dom_html_marquee_element_get_vspace #} - (toHTMLMarqueeElement self)) +getVspace :: + (MonadIO m, HTMLMarqueeElementClass self) => self -> m Word +getVspace self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_marquee_element_get_vspace #} + (toHTMLMarqueeElement self))) -htmlMarqueeElementSetWidth :: - (HTMLMarqueeElementClass self) => self -> String -> IO () -htmlMarqueeElementSetWidth self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_marquee_element_set_width #} - (toHTMLMarqueeElement self) - valPtr +setWidth :: + (MonadIO m, HTMLMarqueeElementClass self, GlibString string) => + self -> string -> m () +setWidth self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_marquee_element_set_width #} + (toHTMLMarqueeElement self) + valPtr) -htmlMarqueeElementGetWidth :: - (HTMLMarqueeElementClass self) => self -> IO String -htmlMarqueeElementGetWidth self - = ({# call webkit_dom_html_marquee_element_get_width #} - (toHTMLMarqueeElement self)) - >>= - readUTFString +getWidth :: + (MonadIO m, HTMLMarqueeElementClass self, GlibString string) => + self -> m string +getWidth self + = liftIO + (({# call webkit_dom_html_marquee_element_get_width #} + (toHTMLMarqueeElement self)) + >>= + readUTFString) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLMediaElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLMediaElement.chs --- a/Graphics/UI/Gtk/WebKit/DOM/HTMLMediaElement.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLMediaElement.chs @@ -1,434 +1,821 @@ -module Graphics.UI.Gtk.WebKit.DOM.HTMLMediaElement - (htmlMediaElementLoad, htmlMediaElementCanPlayType, - htmlMediaElementPlay, htmlMediaElementPause, cNETWORK_EMPTY, - cNETWORK_IDLE, cNETWORK_LOADING, cNETWORK_NO_SOURCE, cHAVE_NOTHING, - cHAVE_METADATA, cHAVE_CURRENT_DATA, cHAVE_FUTURE_DATA, - cHAVE_ENOUGH_DATA, htmlMediaElementGetError, - htmlMediaElementSetSrc, htmlMediaElementGetSrc, - htmlMediaElementGetCurrentSrc, htmlMediaElementGetNetworkState, - htmlMediaElementSetPreload, htmlMediaElementGetPreload, - htmlMediaElementGetBuffered, htmlMediaElementGetReadyState, - htmlMediaElementGetSeeking, htmlMediaElementSetCurrentTime, - htmlMediaElementGetCurrentTime, htmlMediaElementGetInitialTime, - htmlMediaElementGetStartTime, htmlMediaElementGetDuration, - htmlMediaElementGetPaused, htmlMediaElementSetDefaultPlaybackRate, - htmlMediaElementGetDefaultPlaybackRate, - htmlMediaElementSetPlaybackRate, htmlMediaElementGetPlaybackRate, - htmlMediaElementGetPlayed, htmlMediaElementGetSeekable, - htmlMediaElementGetEnded, htmlMediaElementSetAutoplay, - htmlMediaElementGetAutoplay, htmlMediaElementSetLoop, - htmlMediaElementGetLoop, htmlMediaElementSetControls, - htmlMediaElementGetControls, htmlMediaElementSetVolume, - htmlMediaElementGetVolume, htmlMediaElementSetMuted, - htmlMediaElementGetMuted, htmlMediaElementSetDefaultMuted, - htmlMediaElementGetDefaultMuted, - htmlMediaElementSetWebkitPreservesPitch, - htmlMediaElementGetWebkitPreservesPitch, - htmlMediaElementGetWebkitHasClosedCaptions, - htmlMediaElementSetWebkitClosedCaptionsVisible, - htmlMediaElementGetWebkitClosedCaptionsVisible, - htmlMediaElementGetWebkitAudioDecodedByteCount, - htmlMediaElementGetWebkitVideoDecodedByteCount, -#if WEBKIT_CHECK_VERSION(2,2,2) - htmlMediaElementOnwebkitneedkey, -#endif - htmlMediaElementSetMediaGroup, htmlMediaElementGetMediaGroup, - HTMLMediaElement, HTMLMediaElementClass, castToHTMLMediaElement, - gTypeHTMLMediaElement, toHTMLMediaElement) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} -import System.Glib.GError -import Graphics.UI.Gtk.WebKit.DOM.EventM - -#if WEBKIT_CHECK_VERSION(2,0,0) -htmlMediaElementLoad :: (HTMLMediaElementClass self) => self -> IO () -htmlMediaElementLoad = {# call webkit_dom_html_media_element_load #} . toHTMLMediaElement -#else -htmlMediaElementLoad :: - (HTMLMediaElementClass self) => self -> IO () -htmlMediaElementLoad self - = propagateGError $ - \ errorPtr_ -> - {# call webkit_dom_html_media_element_load #} - (toHTMLMediaElement self) - errorPtr_ -#endif - -htmlMediaElementCanPlayType :: - (HTMLMediaElementClass self) => self -> String -> IO String -htmlMediaElementCanPlayType self type' - = (withUTFString type' $ - \ typePtr -> - {# call webkit_dom_html_media_element_can_play_type #} - (toHTMLMediaElement self) - typePtr) - >>= - readUTFString - -htmlMediaElementPlay :: - (HTMLMediaElementClass self) => self -> IO () -htmlMediaElementPlay self - = {# call webkit_dom_html_media_element_play #} - (toHTMLMediaElement self) - -htmlMediaElementPause :: - (HTMLMediaElementClass self) => self -> IO () -htmlMediaElementPause self - = {# call webkit_dom_html_media_element_pause #} - (toHTMLMediaElement self) -cNETWORK_EMPTY = 0 -cNETWORK_IDLE = 1 -cNETWORK_LOADING = 2 -cNETWORK_NO_SOURCE = 3 -cHAVE_NOTHING = 0 -cHAVE_METADATA = 1 -cHAVE_CURRENT_DATA = 2 -cHAVE_FUTURE_DATA = 3 -cHAVE_ENOUGH_DATA = 4 - -htmlMediaElementGetError :: - (HTMLMediaElementClass self) => self -> IO (Maybe MediaError) -htmlMediaElementGetError self - = maybeNull (makeNewGObject mkMediaError) - ({# call webkit_dom_html_media_element_get_error #} - (toHTMLMediaElement self)) - -htmlMediaElementSetSrc :: - (HTMLMediaElementClass self) => self -> String -> IO () -htmlMediaElementSetSrc self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_media_element_set_src #} - (toHTMLMediaElement self) - valPtr - -htmlMediaElementGetSrc :: - (HTMLMediaElementClass self) => self -> IO String -htmlMediaElementGetSrc self - = ({# call webkit_dom_html_media_element_get_src #} - (toHTMLMediaElement self)) - >>= - readUTFString - -htmlMediaElementGetCurrentSrc :: - (HTMLMediaElementClass self) => self -> IO String -htmlMediaElementGetCurrentSrc self - = ({# call webkit_dom_html_media_element_get_current_src #} - (toHTMLMediaElement self)) - >>= - readUTFString - -htmlMediaElementGetNetworkState :: - (HTMLMediaElementClass self) => self -> IO Word -htmlMediaElementGetNetworkState self - = fromIntegral <$> - ({# call webkit_dom_html_media_element_get_network_state #} - (toHTMLMediaElement self)) - -htmlMediaElementSetPreload :: - (HTMLMediaElementClass self) => self -> String -> IO () -htmlMediaElementSetPreload self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_media_element_set_preload #} - (toHTMLMediaElement self) - valPtr - -htmlMediaElementGetPreload :: - (HTMLMediaElementClass self) => self -> IO String -htmlMediaElementGetPreload self - = ({# call webkit_dom_html_media_element_get_preload #} - (toHTMLMediaElement self)) - >>= - readUTFString - -htmlMediaElementGetBuffered :: - (HTMLMediaElementClass self) => self -> IO (Maybe TimeRanges) -htmlMediaElementGetBuffered self - = maybeNull (makeNewGObject mkTimeRanges) - ({# call webkit_dom_html_media_element_get_buffered #} - (toHTMLMediaElement self)) - -htmlMediaElementGetReadyState :: - (HTMLMediaElementClass self) => self -> IO Word -htmlMediaElementGetReadyState self - = fromIntegral <$> - ({# call webkit_dom_html_media_element_get_ready_state #} - (toHTMLMediaElement self)) - -htmlMediaElementGetSeeking :: - (HTMLMediaElementClass self) => self -> IO Bool -htmlMediaElementGetSeeking self - = toBool <$> - ({# call webkit_dom_html_media_element_get_seeking #} - (toHTMLMediaElement self)) - -htmlMediaElementSetCurrentTime :: - (HTMLMediaElementClass self) => self -> Double -> IO () -htmlMediaElementSetCurrentTime self val - = propagateGError $ - \ errorPtr_ -> - {# call webkit_dom_html_media_element_set_current_time #} - (toHTMLMediaElement self) - (realToFrac val) - errorPtr_ - -htmlMediaElementGetCurrentTime :: - (HTMLMediaElementClass self) => self -> IO Double -htmlMediaElementGetCurrentTime self - = realToFrac <$> - ({# call webkit_dom_html_media_element_get_current_time #} - (toHTMLMediaElement self)) - -htmlMediaElementGetInitialTime :: - (HTMLMediaElementClass self) => self -> IO Double -htmlMediaElementGetInitialTime self - = realToFrac <$> - ({# call webkit_dom_html_media_element_get_initial_time #} - (toHTMLMediaElement self)) - -htmlMediaElementGetStartTime :: - (HTMLMediaElementClass self) => self -> IO Double -htmlMediaElementGetStartTime self - = realToFrac <$> - ({# call webkit_dom_html_media_element_get_start_time #} - (toHTMLMediaElement self)) - -htmlMediaElementGetDuration :: - (HTMLMediaElementClass self) => self -> IO Double -htmlMediaElementGetDuration self - = realToFrac <$> - ({# call webkit_dom_html_media_element_get_duration #} - (toHTMLMediaElement self)) - -htmlMediaElementGetPaused :: - (HTMLMediaElementClass self) => self -> IO Bool -htmlMediaElementGetPaused self - = toBool <$> - ({# call webkit_dom_html_media_element_get_paused #} - (toHTMLMediaElement self)) - -htmlMediaElementSetDefaultPlaybackRate :: - (HTMLMediaElementClass self) => self -> Double -> IO () -htmlMediaElementSetDefaultPlaybackRate self val - = {# call webkit_dom_html_media_element_set_default_playback_rate - #} - (toHTMLMediaElement self) - (realToFrac val) - -htmlMediaElementGetDefaultPlaybackRate :: - (HTMLMediaElementClass self) => self -> IO Double -htmlMediaElementGetDefaultPlaybackRate self - = realToFrac <$> - ({# call webkit_dom_html_media_element_get_default_playback_rate #} - (toHTMLMediaElement self)) - -htmlMediaElementSetPlaybackRate :: - (HTMLMediaElementClass self) => self -> Double -> IO () -htmlMediaElementSetPlaybackRate self val - = {# call webkit_dom_html_media_element_set_playback_rate #} - (toHTMLMediaElement self) - (realToFrac val) - -htmlMediaElementGetPlaybackRate :: - (HTMLMediaElementClass self) => self -> IO Double -htmlMediaElementGetPlaybackRate self - = realToFrac <$> - ({# call webkit_dom_html_media_element_get_playback_rate #} - (toHTMLMediaElement self)) - -htmlMediaElementGetPlayed :: - (HTMLMediaElementClass self) => self -> IO (Maybe TimeRanges) -htmlMediaElementGetPlayed self - = maybeNull (makeNewGObject mkTimeRanges) - ({# call webkit_dom_html_media_element_get_played #} - (toHTMLMediaElement self)) - -htmlMediaElementGetSeekable :: - (HTMLMediaElementClass self) => self -> IO (Maybe TimeRanges) -htmlMediaElementGetSeekable self - = maybeNull (makeNewGObject mkTimeRanges) - ({# call webkit_dom_html_media_element_get_seekable #} - (toHTMLMediaElement self)) - -htmlMediaElementGetEnded :: - (HTMLMediaElementClass self) => self -> IO Bool -htmlMediaElementGetEnded self - = toBool <$> - ({# call webkit_dom_html_media_element_get_ended #} - (toHTMLMediaElement self)) - -htmlMediaElementSetAutoplay :: - (HTMLMediaElementClass self) => self -> Bool -> IO () -htmlMediaElementSetAutoplay self val - = {# call webkit_dom_html_media_element_set_autoplay #} - (toHTMLMediaElement self) - (fromBool val) - -htmlMediaElementGetAutoplay :: - (HTMLMediaElementClass self) => self -> IO Bool -htmlMediaElementGetAutoplay self - = toBool <$> - ({# call webkit_dom_html_media_element_get_autoplay #} - (toHTMLMediaElement self)) - -htmlMediaElementSetLoop :: - (HTMLMediaElementClass self) => self -> Bool -> IO () -htmlMediaElementSetLoop self val - = {# call webkit_dom_html_media_element_set_loop #} - (toHTMLMediaElement self) - (fromBool val) - -htmlMediaElementGetLoop :: - (HTMLMediaElementClass self) => self -> IO Bool -htmlMediaElementGetLoop self - = toBool <$> - ({# call webkit_dom_html_media_element_get_loop #} - (toHTMLMediaElement self)) - -htmlMediaElementSetControls :: - (HTMLMediaElementClass self) => self -> Bool -> IO () -htmlMediaElementSetControls self val - = {# call webkit_dom_html_media_element_set_controls #} - (toHTMLMediaElement self) - (fromBool val) - -htmlMediaElementGetControls :: - (HTMLMediaElementClass self) => self -> IO Bool -htmlMediaElementGetControls self - = toBool <$> - ({# call webkit_dom_html_media_element_get_controls #} - (toHTMLMediaElement self)) - -htmlMediaElementSetVolume :: - (HTMLMediaElementClass self) => self -> Double -> IO () -htmlMediaElementSetVolume self val - = propagateGError $ - \ errorPtr_ -> - {# call webkit_dom_html_media_element_set_volume #} - (toHTMLMediaElement self) - (realToFrac val) - errorPtr_ - -htmlMediaElementGetVolume :: - (HTMLMediaElementClass self) => self -> IO Double -htmlMediaElementGetVolume self - = realToFrac <$> - ({# call webkit_dom_html_media_element_get_volume #} - (toHTMLMediaElement self)) - -htmlMediaElementSetMuted :: - (HTMLMediaElementClass self) => self -> Bool -> IO () -htmlMediaElementSetMuted self val - = {# call webkit_dom_html_media_element_set_muted #} - (toHTMLMediaElement self) - (fromBool val) - -htmlMediaElementGetMuted :: - (HTMLMediaElementClass self) => self -> IO Bool -htmlMediaElementGetMuted self - = toBool <$> - ({# call webkit_dom_html_media_element_get_muted #} - (toHTMLMediaElement self)) - -htmlMediaElementSetDefaultMuted :: - (HTMLMediaElementClass self) => self -> Bool -> IO () -htmlMediaElementSetDefaultMuted self val - = {# call webkit_dom_html_media_element_set_default_muted #} - (toHTMLMediaElement self) - (fromBool val) - -htmlMediaElementGetDefaultMuted :: - (HTMLMediaElementClass self) => self -> IO Bool -htmlMediaElementGetDefaultMuted self - = toBool <$> - ({# call webkit_dom_html_media_element_get_default_muted #} - (toHTMLMediaElement self)) - -htmlMediaElementSetWebkitPreservesPitch :: - (HTMLMediaElementClass self) => self -> Bool -> IO () -htmlMediaElementSetWebkitPreservesPitch self val - = {# call webkit_dom_html_media_element_set_webkit_preserves_pitch - #} - (toHTMLMediaElement self) - (fromBool val) - -htmlMediaElementGetWebkitPreservesPitch :: - (HTMLMediaElementClass self) => self -> IO Bool -htmlMediaElementGetWebkitPreservesPitch self - = toBool <$> - ({# call webkit_dom_html_media_element_get_webkit_preserves_pitch - #} - (toHTMLMediaElement self)) - -htmlMediaElementGetWebkitHasClosedCaptions :: - (HTMLMediaElementClass self) => self -> IO Bool -htmlMediaElementGetWebkitHasClosedCaptions self - = toBool <$> - ({# call - webkit_dom_html_media_element_get_webkit_has_closed_captions - #} - (toHTMLMediaElement self)) - -htmlMediaElementSetWebkitClosedCaptionsVisible :: - (HTMLMediaElementClass self) => self -> Bool -> IO () -htmlMediaElementSetWebkitClosedCaptionsVisible self val - = {# call - webkit_dom_html_media_element_set_webkit_closed_captions_visible - #} - (toHTMLMediaElement self) - (fromBool val) - -htmlMediaElementGetWebkitClosedCaptionsVisible :: - (HTMLMediaElementClass self) => self -> IO Bool -htmlMediaElementGetWebkitClosedCaptionsVisible self - = toBool <$> - ({# call - webkit_dom_html_media_element_get_webkit_closed_captions_visible - #} - (toHTMLMediaElement self)) - -htmlMediaElementGetWebkitAudioDecodedByteCount :: - (HTMLMediaElementClass self) => self -> IO Word -htmlMediaElementGetWebkitAudioDecodedByteCount self - = fromIntegral <$> - ({# call - webkit_dom_html_media_element_get_webkit_audio_decoded_byte_count - #} - (toHTMLMediaElement self)) - -htmlMediaElementGetWebkitVideoDecodedByteCount :: - (HTMLMediaElementClass self) => self -> IO Word -htmlMediaElementGetWebkitVideoDecodedByteCount self - = fromIntegral <$> - ({# call - webkit_dom_html_media_element_get_webkit_video_decoded_byte_count - #} - (toHTMLMediaElement self)) - -#if WEBKIT_CHECK_VERSION(2,2,2) -htmlMediaElementOnwebkitneedkey :: - (HTMLMediaElementClass self) => - Signal self (EventM UIEvent self ()) -htmlMediaElementOnwebkitneedkey = (connect "webkitneedkey") -#endif - -htmlMediaElementSetMediaGroup :: - (HTMLMediaElementClass self) => self -> String -> IO () -htmlMediaElementSetMediaGroup self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_media_element_set_media_group #} - (toHTMLMediaElement self) - valPtr - -htmlMediaElementGetMediaGroup :: - (HTMLMediaElementClass self) => self -> IO String -htmlMediaElementGetMediaGroup self - = ({# call webkit_dom_html_media_element_get_media_group #} - (toHTMLMediaElement self)) - >>= - readUTFString +module Graphics.UI.Gtk.WebKit.DOM.HTMLMediaElement( +#if WEBKIT_CHECK_VERSION(2,2,2) +load, +#endif +#if WEBKIT_CHECK_VERSION(2,7,0) +canPlayType, +#endif +play, +pause, +#if WEBKIT_CHECK_VERSION(2,4,0) +fastSeek, +#endif +#if WEBKIT_CHECK_VERSION(99,0,0) +webkitGenerateKeyRequest, +webkitAddKey, +webkitCancelKeyRequest, +webkitSetMediaKeys, +#endif +#if WEBKIT_CHECK_VERSION(2,4,0) +addTextTrack, +#endif +#if WEBKIT_CHECK_VERSION(99,0,0) +getVideoPlaybackQuality, +#endif +#if WEBKIT_CHECK_VERSION(2,4,0) +webkitShowPlaybackTargetPicker, +#endif +pattern NETWORK_EMPTY, +pattern NETWORK_IDLE, +pattern NETWORK_LOADING, +pattern NETWORK_NO_SOURCE, +pattern HAVE_NOTHING, +pattern HAVE_METADATA, +pattern HAVE_CURRENT_DATA, +pattern HAVE_FUTURE_DATA, +pattern HAVE_ENOUGH_DATA, +getError, +setSrc, +getSrc, +getCurrentSrc, +getNetworkState, +setPreload, +getPreload, +getBuffered, +getReadyState, +getSeeking, +setCurrentTime, +getCurrentTime, +getDuration, +getPaused, +setDefaultPlaybackRate, +getDefaultPlaybackRate, +setPlaybackRate, +getPlaybackRate, +getPlayed, +getSeekable, +getEnded, +setAutoplay, +getAutoplay, +setLoop, +getLoop, +setControls, +getControls, +setVolume, +getVolume, +setMuted, +getMuted, +setDefaultMuted, +getDefaultMuted, +emptied, +loadedMetadata, +loadedData, +canPlay, +canPlayThrough, +playing, +ended, +waiting, +durationChange, +timeUpdate, +playEvent, +pauseEvent, +rateChange, +volumeChange, +setWebkitPreservesPitch, +getWebkitPreservesPitch, +getWebkitHasClosedCaptions, +setWebkitClosedCaptionsVisible, +getWebkitClosedCaptionsVisible, +getWebkitAudioDecodedByteCount, +getWebkitVideoDecodedByteCount, +webKitKeyAdded, +webKitKeyError, +webKitKeyMessage, +webKitNeedKey, +#if WEBKIT_CHECK_VERSION(99,0,0) +getWebkitKeys, +#endif +#if WEBKIT_CHECK_VERSION(2,4,0) +getAudioTracks, +getTextTracks, +getVideoTracks, +#endif +setMediaGroup, +getMediaGroup, +#if WEBKIT_CHECK_VERSION(2,4,0) +getWebkitCurrentPlaybackTargetIsWireless, +#endif +webKitCurrentPlaybackTargetIsWirelessChanged, +webKitPlaybackTargetAvailabilityChanged, +#if WEBKIT_CHECK_VERSION(99,0,0) +setSrcObject, +getSrcObject, +#endif +HTMLMediaElement, +castToHTMLMediaElement, +gTypeHTMLMediaElement, +HTMLMediaElementClass, +toHTMLMediaElement, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures +import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + + +#if WEBKIT_CHECK_VERSION(2,2,2) +load :: (MonadIO m, HTMLMediaElementClass self) => self -> m () +load self + = liftIO + ({# call webkit_dom_html_media_element_load #} + (toHTMLMediaElement self)) +#endif + +#if WEBKIT_CHECK_VERSION(2,7,0) +canPlayType :: + (MonadIO m, HTMLMediaElementClass self, GlibString string) => + self -> string -> (Maybe string) -> m string +canPlayType self type' keySystem + = liftIO + ((maybeWith withUTFString keySystem $ + \ keySystemPtr -> + withUTFString type' $ + \ typePtr -> + {# call webkit_dom_html_media_element_can_play_type #} + (toHTMLMediaElement self) + typePtr + keySystemPtr) + >>= + readUTFString) +#endif + +play :: (MonadIO m, HTMLMediaElementClass self) => self -> m () +play self + = liftIO + ({# call webkit_dom_html_media_element_play #} + (toHTMLMediaElement self)) + +pause :: (MonadIO m, HTMLMediaElementClass self) => self -> m () +pause self + = liftIO + ({# call webkit_dom_html_media_element_pause #} + (toHTMLMediaElement self)) + +#if WEBKIT_CHECK_VERSION(2,4,0) +fastSeek :: + (MonadIO m, HTMLMediaElementClass self) => self -> Double -> m () +fastSeek self time + = liftIO + ({# call webkit_dom_html_media_element_fast_seek #} + (toHTMLMediaElement self) + (realToFrac time)) +#endif + +#if WEBKIT_CHECK_VERSION(99,0,0) +webkitGenerateKeyRequest :: + (MonadIO m, HTMLMediaElementClass self, Uint8ArrayClass initData, + GlibString string) => + self -> (Maybe string) -> Maybe initData -> m () +webkitGenerateKeyRequest self keySystem initData + = liftIO + (propagateGError $ + \ errorPtr_ -> + maybeWith withUTFString keySystem $ + \ keySystemPtr -> + {# call webkit_dom_html_media_element_webkit_generate_key_request + #} + (toHTMLMediaElement self) + keySystemPtr + (maybe (Uint8Array nullForeignPtr) toUint8Array initData) + errorPtr_) + +webkitAddKey :: + (MonadIO m, HTMLMediaElementClass self, Uint8ArrayClass key, + Uint8ArrayClass initData, GlibString string) => + self -> + (Maybe string) -> Maybe key -> Maybe initData -> string -> m () +webkitAddKey self keySystem key initData sessionId + = liftIO + (propagateGError $ + \ errorPtr_ -> + withUTFString sessionId $ + \ sessionIdPtr -> + maybeWith withUTFString keySystem $ + \ keySystemPtr -> + {# call webkit_dom_html_media_element_webkit_add_key #} + (toHTMLMediaElement self) + keySystemPtr + (maybe (Uint8Array nullForeignPtr) toUint8Array key) + (maybe (Uint8Array nullForeignPtr) toUint8Array initData) + sessionIdPtr + errorPtr_) + +webkitCancelKeyRequest :: + (MonadIO m, HTMLMediaElementClass self, GlibString string) => + self -> (Maybe string) -> string -> m () +webkitCancelKeyRequest self keySystem sessionId + = liftIO + (propagateGError $ + \ errorPtr_ -> + withUTFString sessionId $ + \ sessionIdPtr -> + maybeWith withUTFString keySystem $ + \ keySystemPtr -> + {# call webkit_dom_html_media_element_webkit_cancel_key_request #} + (toHTMLMediaElement self) + keySystemPtr + sessionIdPtr + errorPtr_) + +webkitSetMediaKeys :: + (MonadIO m, HTMLMediaElementClass self, + MediaKeysClass mediaKeys) => + self -> Maybe mediaKeys -> m () +webkitSetMediaKeys self mediaKeys + = liftIO + ({# call webkit_dom_html_media_element_webkit_set_media_keys #} + (toHTMLMediaElement self) + (maybe (MediaKeys nullForeignPtr) toMediaKeys mediaKeys)) +#endif + +#if WEBKIT_CHECK_VERSION(2,4,0) +addTextTrack :: + (MonadIO m, HTMLMediaElementClass self, GlibString string) => + self -> string -> string -> string -> m (Maybe TextTrack) +addTextTrack self kind label language + = liftIO + (maybeNull (makeNewGObject mkTextTrack) + (propagateGError $ + \ errorPtr_ -> + withUTFString language $ + \ languagePtr -> + withUTFString label $ + \ labelPtr -> + withUTFString kind $ + \ kindPtr -> + {# call webkit_dom_html_media_element_add_text_track #} + (toHTMLMediaElement self) + kindPtr + labelPtr + languagePtr + errorPtr_)) +#endif + +#if WEBKIT_CHECK_VERSION(99,0,0) +getVideoPlaybackQuality :: + (MonadIO m, HTMLMediaElementClass self) => + self -> m (Maybe VideoPlaybackQuality) +getVideoPlaybackQuality self + = liftIO + (maybeNull (makeNewGObject mkVideoPlaybackQuality) + ({# call webkit_dom_html_media_element_get_video_playback_quality + #} + (toHTMLMediaElement self))) +#endif + +#if WEBKIT_CHECK_VERSION(2,4,0) +webkitShowPlaybackTargetPicker :: + (MonadIO m, HTMLMediaElementClass self) => self -> m () +webkitShowPlaybackTargetPicker self + = liftIO + ({# call + webkit_dom_html_media_element_webkit_show_playback_target_picker + #} + (toHTMLMediaElement self)) +#endif +pattern NETWORK_EMPTY = 0 +pattern NETWORK_IDLE = 1 +pattern NETWORK_LOADING = 2 +pattern NETWORK_NO_SOURCE = 3 +pattern HAVE_NOTHING = 0 +pattern HAVE_METADATA = 1 +pattern HAVE_CURRENT_DATA = 2 +pattern HAVE_FUTURE_DATA = 3 +pattern HAVE_ENOUGH_DATA = 4 + +getError :: + (MonadIO m, HTMLMediaElementClass self) => + self -> m (Maybe MediaError) +getError self + = liftIO + (maybeNull (makeNewGObject mkMediaError) + ({# call webkit_dom_html_media_element_get_error #} + (toHTMLMediaElement self))) + +setSrc :: + (MonadIO m, HTMLMediaElementClass self, GlibString string) => + self -> string -> m () +setSrc self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_media_element_set_src #} + (toHTMLMediaElement self) + valPtr) + +getSrc :: + (MonadIO m, HTMLMediaElementClass self, GlibString string) => + self -> m string +getSrc self + = liftIO + (({# call webkit_dom_html_media_element_get_src #} + (toHTMLMediaElement self)) + >>= + readUTFString) + +getCurrentSrc :: + (MonadIO m, HTMLMediaElementClass self, GlibString string) => + self -> m string +getCurrentSrc self + = liftIO + (({# call webkit_dom_html_media_element_get_current_src #} + (toHTMLMediaElement self)) + >>= + readUTFString) + +getNetworkState :: + (MonadIO m, HTMLMediaElementClass self) => self -> m Word +getNetworkState self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_media_element_get_network_state #} + (toHTMLMediaElement self))) + +setPreload :: + (MonadIO m, HTMLMediaElementClass self, GlibString string) => + self -> string -> m () +setPreload self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_media_element_set_preload #} + (toHTMLMediaElement self) + valPtr) + +getPreload :: + (MonadIO m, HTMLMediaElementClass self, GlibString string) => + self -> m string +getPreload self + = liftIO + (({# call webkit_dom_html_media_element_get_preload #} + (toHTMLMediaElement self)) + >>= + readUTFString) + +getBuffered :: + (MonadIO m, HTMLMediaElementClass self) => + self -> m (Maybe TimeRanges) +getBuffered self + = liftIO + (maybeNull (makeNewGObject mkTimeRanges) + ({# call webkit_dom_html_media_element_get_buffered #} + (toHTMLMediaElement self))) + +getReadyState :: + (MonadIO m, HTMLMediaElementClass self) => self -> m Word +getReadyState self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_media_element_get_ready_state #} + (toHTMLMediaElement self))) + +getSeeking :: + (MonadIO m, HTMLMediaElementClass self) => self -> m Bool +getSeeking self + = liftIO + (toBool <$> + ({# call webkit_dom_html_media_element_get_seeking #} + (toHTMLMediaElement self))) + +setCurrentTime :: + (MonadIO m, HTMLMediaElementClass self) => self -> Double -> m () +setCurrentTime self val + = liftIO + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_html_media_element_set_current_time #} + (toHTMLMediaElement self) + (realToFrac val) + errorPtr_) + +getCurrentTime :: + (MonadIO m, HTMLMediaElementClass self) => self -> m Double +getCurrentTime self + = liftIO + (realToFrac <$> + ({# call webkit_dom_html_media_element_get_current_time #} + (toHTMLMediaElement self))) + +getDuration :: + (MonadIO m, HTMLMediaElementClass self) => self -> m Double +getDuration self + = liftIO + (realToFrac <$> + ({# call webkit_dom_html_media_element_get_duration #} + (toHTMLMediaElement self))) + +getPaused :: + (MonadIO m, HTMLMediaElementClass self) => self -> m Bool +getPaused self + = liftIO + (toBool <$> + ({# call webkit_dom_html_media_element_get_paused #} + (toHTMLMediaElement self))) + +setDefaultPlaybackRate :: + (MonadIO m, HTMLMediaElementClass self) => self -> Double -> m () +setDefaultPlaybackRate self val + = liftIO + ({# call webkit_dom_html_media_element_set_default_playback_rate #} + (toHTMLMediaElement self) + (realToFrac val)) + +getDefaultPlaybackRate :: + (MonadIO m, HTMLMediaElementClass self) => self -> m Double +getDefaultPlaybackRate self + = liftIO + (realToFrac <$> + ({# call webkit_dom_html_media_element_get_default_playback_rate #} + (toHTMLMediaElement self))) + +setPlaybackRate :: + (MonadIO m, HTMLMediaElementClass self) => self -> Double -> m () +setPlaybackRate self val + = liftIO + ({# call webkit_dom_html_media_element_set_playback_rate #} + (toHTMLMediaElement self) + (realToFrac val)) + +getPlaybackRate :: + (MonadIO m, HTMLMediaElementClass self) => self -> m Double +getPlaybackRate self + = liftIO + (realToFrac <$> + ({# call webkit_dom_html_media_element_get_playback_rate #} + (toHTMLMediaElement self))) + +getPlayed :: + (MonadIO m, HTMLMediaElementClass self) => + self -> m (Maybe TimeRanges) +getPlayed self + = liftIO + (maybeNull (makeNewGObject mkTimeRanges) + ({# call webkit_dom_html_media_element_get_played #} + (toHTMLMediaElement self))) + +getSeekable :: + (MonadIO m, HTMLMediaElementClass self) => + self -> m (Maybe TimeRanges) +getSeekable self + = liftIO + (maybeNull (makeNewGObject mkTimeRanges) + ({# call webkit_dom_html_media_element_get_seekable #} + (toHTMLMediaElement self))) + +getEnded :: + (MonadIO m, HTMLMediaElementClass self) => self -> m Bool +getEnded self + = liftIO + (toBool <$> + ({# call webkit_dom_html_media_element_get_ended #} + (toHTMLMediaElement self))) + +setAutoplay :: + (MonadIO m, HTMLMediaElementClass self) => self -> Bool -> m () +setAutoplay self val + = liftIO + ({# call webkit_dom_html_media_element_set_autoplay #} + (toHTMLMediaElement self) + (fromBool val)) + +getAutoplay :: + (MonadIO m, HTMLMediaElementClass self) => self -> m Bool +getAutoplay self + = liftIO + (toBool <$> + ({# call webkit_dom_html_media_element_get_autoplay #} + (toHTMLMediaElement self))) + +setLoop :: + (MonadIO m, HTMLMediaElementClass self) => self -> Bool -> m () +setLoop self val + = liftIO + ({# call webkit_dom_html_media_element_set_loop #} + (toHTMLMediaElement self) + (fromBool val)) + +getLoop :: + (MonadIO m, HTMLMediaElementClass self) => self -> m Bool +getLoop self + = liftIO + (toBool <$> + ({# call webkit_dom_html_media_element_get_loop #} + (toHTMLMediaElement self))) + +setControls :: + (MonadIO m, HTMLMediaElementClass self) => self -> Bool -> m () +setControls self val + = liftIO + ({# call webkit_dom_html_media_element_set_controls #} + (toHTMLMediaElement self) + (fromBool val)) + +getControls :: + (MonadIO m, HTMLMediaElementClass self) => self -> m Bool +getControls self + = liftIO + (toBool <$> + ({# call webkit_dom_html_media_element_get_controls #} + (toHTMLMediaElement self))) + +setVolume :: + (MonadIO m, HTMLMediaElementClass self) => self -> Double -> m () +setVolume self val + = liftIO + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_html_media_element_set_volume #} + (toHTMLMediaElement self) + (realToFrac val) + errorPtr_) + +getVolume :: + (MonadIO m, HTMLMediaElementClass self) => self -> m Double +getVolume self + = liftIO + (realToFrac <$> + ({# call webkit_dom_html_media_element_get_volume #} + (toHTMLMediaElement self))) + +setMuted :: + (MonadIO m, HTMLMediaElementClass self) => self -> Bool -> m () +setMuted self val + = liftIO + ({# call webkit_dom_html_media_element_set_muted #} + (toHTMLMediaElement self) + (fromBool val)) + +getMuted :: + (MonadIO m, HTMLMediaElementClass self) => self -> m Bool +getMuted self + = liftIO + (toBool <$> + ({# call webkit_dom_html_media_element_get_muted #} + (toHTMLMediaElement self))) + +setDefaultMuted :: + (MonadIO m, HTMLMediaElementClass self) => self -> Bool -> m () +setDefaultMuted self val + = liftIO + ({# call webkit_dom_html_media_element_set_default_muted #} + (toHTMLMediaElement self) + (fromBool val)) + +getDefaultMuted :: + (MonadIO m, HTMLMediaElementClass self) => self -> m Bool +getDefaultMuted self + = liftIO + (toBool <$> + ({# call webkit_dom_html_media_element_get_default_muted #} + (toHTMLMediaElement self))) + +emptied :: (HTMLMediaElementClass self) => EventName self Event +emptied = EventName "emptied" + +loadedMetadata :: + (HTMLMediaElementClass self) => EventName self Event +loadedMetadata = EventName "loadedmetadata" + +loadedData :: (HTMLMediaElementClass self) => EventName self Event +loadedData = EventName "loadeddata" + +canPlay :: (HTMLMediaElementClass self) => EventName self Event +canPlay = EventName "canplay" + +canPlayThrough :: + (HTMLMediaElementClass self) => EventName self Event +canPlayThrough = EventName "canplaythrough" + +playing :: (HTMLMediaElementClass self) => EventName self Event +playing = EventName "playing" + +ended :: (HTMLMediaElementClass self) => EventName self Event +ended = EventName "ended" + +waiting :: (HTMLMediaElementClass self) => EventName self Event +waiting = EventName "waiting" + +durationChange :: + (HTMLMediaElementClass self) => EventName self Event +durationChange = EventName "durationchange" + +timeUpdate :: (HTMLMediaElementClass self) => EventName self Event +timeUpdate = EventName "timeupdate" + +playEvent :: (HTMLMediaElementClass self) => EventName self Event +playEvent = EventName "play" + +pauseEvent :: (HTMLMediaElementClass self) => EventName self Event +pauseEvent = EventName "pause" + +rateChange :: (HTMLMediaElementClass self) => EventName self Event +rateChange = EventName "ratechange" + +volumeChange :: + (HTMLMediaElementClass self) => EventName self Event +volumeChange = EventName "volumechange" + +setWebkitPreservesPitch :: + (MonadIO m, HTMLMediaElementClass self) => self -> Bool -> m () +setWebkitPreservesPitch self val + = liftIO + ({# call webkit_dom_html_media_element_set_webkit_preserves_pitch + #} + (toHTMLMediaElement self) + (fromBool val)) + +getWebkitPreservesPitch :: + (MonadIO m, HTMLMediaElementClass self) => self -> m Bool +getWebkitPreservesPitch self + = liftIO + (toBool <$> + ({# call webkit_dom_html_media_element_get_webkit_preserves_pitch + #} + (toHTMLMediaElement self))) + +getWebkitHasClosedCaptions :: + (MonadIO m, HTMLMediaElementClass self) => self -> m Bool +getWebkitHasClosedCaptions self + = liftIO + (toBool <$> + ({# call + webkit_dom_html_media_element_get_webkit_has_closed_captions + #} + (toHTMLMediaElement self))) + +setWebkitClosedCaptionsVisible :: + (MonadIO m, HTMLMediaElementClass self) => self -> Bool -> m () +setWebkitClosedCaptionsVisible self val + = liftIO + ({# call + webkit_dom_html_media_element_set_webkit_closed_captions_visible + #} + (toHTMLMediaElement self) + (fromBool val)) + +getWebkitClosedCaptionsVisible :: + (MonadIO m, HTMLMediaElementClass self) => self -> m Bool +getWebkitClosedCaptionsVisible self + = liftIO + (toBool <$> + ({# call + webkit_dom_html_media_element_get_webkit_closed_captions_visible + #} + (toHTMLMediaElement self))) + +getWebkitAudioDecodedByteCount :: + (MonadIO m, HTMLMediaElementClass self) => self -> m Word +getWebkitAudioDecodedByteCount self + = liftIO + (fromIntegral <$> + ({# call + webkit_dom_html_media_element_get_webkit_audio_decoded_byte_count + #} + (toHTMLMediaElement self))) + +getWebkitVideoDecodedByteCount :: + (MonadIO m, HTMLMediaElementClass self) => self -> m Word +getWebkitVideoDecodedByteCount self + = liftIO + (fromIntegral <$> + ({# call + webkit_dom_html_media_element_get_webkit_video_decoded_byte_count + #} + (toHTMLMediaElement self))) + +webKitKeyAdded :: + (HTMLMediaElementClass self) => EventName self Event +webKitKeyAdded = EventName "webkitkeyadded" + +webKitKeyError :: + (HTMLMediaElementClass self) => EventName self Event +webKitKeyError = EventName "webkitkeyerror" + +webKitKeyMessage :: + (HTMLMediaElementClass self) => EventName self Event +webKitKeyMessage = EventName "webkitkeymessage" + +webKitNeedKey :: + (HTMLMediaElementClass self) => EventName self Event +webKitNeedKey = EventName "webkitneedkey" + +#if WEBKIT_CHECK_VERSION(99,0,0) +getWebkitKeys :: + (MonadIO m, HTMLMediaElementClass self) => + self -> m (Maybe MediaKeys) +getWebkitKeys self + = liftIO + (maybeNull (makeNewGObject mkMediaKeys) + ({# call webkit_dom_html_media_element_get_webkit_keys #} + (toHTMLMediaElement self))) +#endif + +#if WEBKIT_CHECK_VERSION(2,4,0) +getAudioTracks :: + (MonadIO m, HTMLMediaElementClass self) => + self -> m (Maybe AudioTrackList) +getAudioTracks self + = liftIO + (maybeNull (makeNewGObject mkAudioTrackList) + ({# call webkit_dom_html_media_element_get_audio_tracks #} + (toHTMLMediaElement self))) + +getTextTracks :: + (MonadIO m, HTMLMediaElementClass self) => + self -> m (Maybe TextTrackList) +getTextTracks self + = liftIO + (maybeNull (makeNewGObject mkTextTrackList) + ({# call webkit_dom_html_media_element_get_text_tracks #} + (toHTMLMediaElement self))) + +getVideoTracks :: + (MonadIO m, HTMLMediaElementClass self) => + self -> m (Maybe VideoTrackList) +getVideoTracks self + = liftIO + (maybeNull (makeNewGObject mkVideoTrackList) + ({# call webkit_dom_html_media_element_get_video_tracks #} + (toHTMLMediaElement self))) +#endif + +setMediaGroup :: + (MonadIO m, HTMLMediaElementClass self, GlibString string) => + self -> (Maybe string) -> m () +setMediaGroup self val + = liftIO + (maybeWith withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_media_element_set_media_group #} + (toHTMLMediaElement self) + valPtr) + +getMediaGroup :: + (MonadIO m, HTMLMediaElementClass self, GlibString string) => + self -> m (Maybe string) +getMediaGroup self + = liftIO + (({# call webkit_dom_html_media_element_get_media_group #} + (toHTMLMediaElement self)) + >>= + maybePeek readUTFString) + +#if WEBKIT_CHECK_VERSION(2,4,0) +getWebkitCurrentPlaybackTargetIsWireless :: + (MonadIO m, HTMLMediaElementClass self) => self -> m Bool +getWebkitCurrentPlaybackTargetIsWireless self + = liftIO + (toBool <$> + ({# call + webkit_dom_html_media_element_get_webkit_current_playback_target_is_wireless + #} + (toHTMLMediaElement self))) +#endif + +webKitCurrentPlaybackTargetIsWirelessChanged :: + (HTMLMediaElementClass self) => EventName self Event +webKitCurrentPlaybackTargetIsWirelessChanged + = EventName "webkitcurrentplaybacktargetiswirelesschanged" + +webKitPlaybackTargetAvailabilityChanged :: + (HTMLMediaElementClass self) => EventName self Event +webKitPlaybackTargetAvailabilityChanged + = EventName "webkitplaybacktargetavailabilitychanged" + +#if WEBKIT_CHECK_VERSION(99,0,0) +setSrcObject :: + (MonadIO m, MediaStreamClass val, HTMLMediaElementClass self) => + self -> Maybe val -> m () +setSrcObject self val + = liftIO + ({# call webkit_dom_html_media_element_set_src_object #} + (toHTMLMediaElement self) + (maybe (MediaStream nullForeignPtr) toMediaStream val)) + +getSrcObject :: + (MonadIO m, HTMLMediaElementClass self) => + self -> m (Maybe MediaStream) +getSrcObject self + = liftIO + ({# call webkit_dom_html_media_element_get_src_object #} + (toHTMLMediaElement self)) +#endif diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLMenuElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLMenuElement.chs --- a/Graphics/UI/Gtk/WebKit/DOM/HTMLMenuElement.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLMenuElement.chs @@ -1,25 +1,39 @@ -module Graphics.UI.Gtk.WebKit.DOM.HTMLMenuElement - (htmlMenuElementSetCompact, htmlMenuElementGetCompact, - HTMLMenuElement, HTMLMenuElementClass, castToHTMLMenuElement, - gTypeHTMLMenuElement, toHTMLMenuElement) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.HTMLMenuElement( +setCompact, +getCompact, +HTMLMenuElement, +castToHTMLMenuElement, +gTypeHTMLMenuElement, +HTMLMenuElementClass, +toHTMLMenuElement, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -htmlMenuElementSetCompact :: - (HTMLMenuElementClass self) => self -> Bool -> IO () -htmlMenuElementSetCompact self val - = {# call webkit_dom_html_menu_element_set_compact #} - (toHTMLMenuElement self) - (fromBool val) +setCompact :: + (MonadIO m, HTMLMenuElementClass self) => self -> Bool -> m () +setCompact self val + = liftIO + ({# call webkit_dom_html_menu_element_set_compact #} + (toHTMLMenuElement self) + (fromBool val)) -htmlMenuElementGetCompact :: - (HTMLMenuElementClass self) => self -> IO Bool -htmlMenuElementGetCompact self - = toBool <$> - ({# call webkit_dom_html_menu_element_get_compact #} - (toHTMLMenuElement self)) +getCompact :: + (MonadIO m, HTMLMenuElementClass self) => self -> m Bool +getCompact self + = liftIO + (toBool <$> + ({# call webkit_dom_html_menu_element_get_compact #} + (toHTMLMenuElement self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLMetaElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLMetaElement.chs --- a/Graphics/UI/Gtk/WebKit/DOM/HTMLMetaElement.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLMetaElement.chs @@ -1,82 +1,113 @@ -module Graphics.UI.Gtk.WebKit.DOM.HTMLMetaElement - (htmlMetaElementSetContent, htmlMetaElementGetContent, - htmlMetaElementSetHttpEquiv, htmlMetaElementGetHttpEquiv, - htmlMetaElementSetName, htmlMetaElementGetName, - htmlMetaElementSetScheme, htmlMetaElementGetScheme, - HTMLMetaElement, HTMLMetaElementClass, castToHTMLMetaElement, - gTypeHTMLMetaElement, toHTMLMetaElement) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.HTMLMetaElement( +setContent, +getContent, +setHttpEquiv, +getHttpEquiv, +setName, +getName, +setScheme, +getScheme, +HTMLMetaElement, +castToHTMLMetaElement, +gTypeHTMLMetaElement, +HTMLMetaElementClass, +toHTMLMetaElement, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -htmlMetaElementSetContent :: - (HTMLMetaElementClass self) => self -> String -> IO () -htmlMetaElementSetContent self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_meta_element_set_content #} - (toHTMLMetaElement self) - valPtr +setContent :: + (MonadIO m, HTMLMetaElementClass self, GlibString string) => + self -> string -> m () +setContent self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_meta_element_set_content #} + (toHTMLMetaElement self) + valPtr) -htmlMetaElementGetContent :: - (HTMLMetaElementClass self) => self -> IO String -htmlMetaElementGetContent self - = ({# call webkit_dom_html_meta_element_get_content #} - (toHTMLMetaElement self)) - >>= - readUTFString +getContent :: + (MonadIO m, HTMLMetaElementClass self, GlibString string) => + self -> m string +getContent self + = liftIO + (({# call webkit_dom_html_meta_element_get_content #} + (toHTMLMetaElement self)) + >>= + readUTFString) -htmlMetaElementSetHttpEquiv :: - (HTMLMetaElementClass self) => self -> String -> IO () -htmlMetaElementSetHttpEquiv self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_meta_element_set_http_equiv #} - (toHTMLMetaElement self) - valPtr +setHttpEquiv :: + (MonadIO m, HTMLMetaElementClass self, GlibString string) => + self -> string -> m () +setHttpEquiv self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_meta_element_set_http_equiv #} + (toHTMLMetaElement self) + valPtr) -htmlMetaElementGetHttpEquiv :: - (HTMLMetaElementClass self) => self -> IO String -htmlMetaElementGetHttpEquiv self - = ({# call webkit_dom_html_meta_element_get_http_equiv #} - (toHTMLMetaElement self)) - >>= - readUTFString +getHttpEquiv :: + (MonadIO m, HTMLMetaElementClass self, GlibString string) => + self -> m string +getHttpEquiv self + = liftIO + (({# call webkit_dom_html_meta_element_get_http_equiv #} + (toHTMLMetaElement self)) + >>= + readUTFString) -htmlMetaElementSetName :: - (HTMLMetaElementClass self) => self -> String -> IO () -htmlMetaElementSetName self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_meta_element_set_name #} - (toHTMLMetaElement self) - valPtr +setName :: + (MonadIO m, HTMLMetaElementClass self, GlibString string) => + self -> string -> m () +setName self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_meta_element_set_name #} + (toHTMLMetaElement self) + valPtr) -htmlMetaElementGetName :: - (HTMLMetaElementClass self) => self -> IO String -htmlMetaElementGetName self - = ({# call webkit_dom_html_meta_element_get_name #} - (toHTMLMetaElement self)) - >>= - readUTFString +getName :: + (MonadIO m, HTMLMetaElementClass self, GlibString string) => + self -> m string +getName self + = liftIO + (({# call webkit_dom_html_meta_element_get_name #} + (toHTMLMetaElement self)) + >>= + readUTFString) -htmlMetaElementSetScheme :: - (HTMLMetaElementClass self) => self -> String -> IO () -htmlMetaElementSetScheme self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_meta_element_set_scheme #} - (toHTMLMetaElement self) - valPtr +setScheme :: + (MonadIO m, HTMLMetaElementClass self, GlibString string) => + self -> string -> m () +setScheme self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_meta_element_set_scheme #} + (toHTMLMetaElement self) + valPtr) -htmlMetaElementGetScheme :: - (HTMLMetaElementClass self) => self -> IO String -htmlMetaElementGetScheme self - = ({# call webkit_dom_html_meta_element_get_scheme #} - (toHTMLMetaElement self)) - >>= - readUTFString +getScheme :: + (MonadIO m, HTMLMetaElementClass self, GlibString string) => + self -> m string +getScheme self + = liftIO + (({# call webkit_dom_html_meta_element_get_scheme #} + (toHTMLMetaElement self)) + >>= + readUTFString) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLModElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLModElement.chs --- a/Graphics/UI/Gtk/WebKit/DOM/HTMLModElement.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLModElement.chs @@ -1,46 +1,67 @@ -module Graphics.UI.Gtk.WebKit.DOM.HTMLModElement - (htmlModElementSetCite, htmlModElementGetCite, - htmlModElementSetDateTime, htmlModElementGetDateTime, - HTMLModElement, HTMLModElementClass, castToHTMLModElement, - gTypeHTMLModElement, toHTMLModElement) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.HTMLModElement( +setCite, +getCite, +setDateTime, +getDateTime, +HTMLModElement, +castToHTMLModElement, +gTypeHTMLModElement, +HTMLModElementClass, +toHTMLModElement, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -htmlModElementSetCite :: - (HTMLModElementClass self) => self -> String -> IO () -htmlModElementSetCite self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_mod_element_set_cite #} - (toHTMLModElement self) - valPtr +setCite :: + (MonadIO m, HTMLModElementClass self, GlibString string) => + self -> string -> m () +setCite self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_mod_element_set_cite #} + (toHTMLModElement self) + valPtr) -htmlModElementGetCite :: - (HTMLModElementClass self) => self -> IO String -htmlModElementGetCite self - = ({# call webkit_dom_html_mod_element_get_cite #} - (toHTMLModElement self)) - >>= - readUTFString +getCite :: + (MonadIO m, HTMLModElementClass self, GlibString string) => + self -> m string +getCite self + = liftIO + (({# call webkit_dom_html_mod_element_get_cite #} + (toHTMLModElement self)) + >>= + readUTFString) -htmlModElementSetDateTime :: - (HTMLModElementClass self) => self -> String -> IO () -htmlModElementSetDateTime self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_mod_element_set_date_time #} - (toHTMLModElement self) - valPtr +setDateTime :: + (MonadIO m, HTMLModElementClass self, GlibString string) => + self -> string -> m () +setDateTime self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_mod_element_set_date_time #} + (toHTMLModElement self) + valPtr) -htmlModElementGetDateTime :: - (HTMLModElementClass self) => self -> IO String -htmlModElementGetDateTime self - = ({# call webkit_dom_html_mod_element_get_date_time #} - (toHTMLModElement self)) - >>= - readUTFString +getDateTime :: + (MonadIO m, HTMLModElementClass self, GlibString string) => + self -> m string +getDateTime self + = liftIO + (({# call webkit_dom_html_mod_element_get_date_time #} + (toHTMLModElement self)) + >>= + readUTFString) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLOListElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLOListElement.chs --- a/Graphics/UI/Gtk/WebKit/DOM/HTMLOListElement.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLOListElement.chs @@ -1,55 +1,75 @@ -module Graphics.UI.Gtk.WebKit.DOM.HTMLOListElement - (htmloListElementSetCompact, htmloListElementGetCompact, - htmloListElementSetStart, htmloListElementGetStart, - htmloListElementSetReversed, htmloListElementGetReversed, - HTMLOListElement, HTMLOListElementClass, castToHTMLOListElement, - gTypeHTMLOListElement, toHTMLOListElement) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.HTMLOListElement( +setCompact, +getCompact, +setStart, +getStart, +setReversed, +getReversed, +HTMLOListElement, +castToHTMLOListElement, +gTypeHTMLOListElement, +HTMLOListElementClass, +toHTMLOListElement, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -htmloListElementSetCompact :: - (HTMLOListElementClass self) => self -> Bool -> IO () -htmloListElementSetCompact self val - = {# call webkit_dom_htmlo_list_element_set_compact #} - (toHTMLOListElement self) - (fromBool val) +setCompact :: + (MonadIO m, HTMLOListElementClass self) => self -> Bool -> m () +setCompact self val + = liftIO + ({# call webkit_dom_htmlo_list_element_set_compact #} + (toHTMLOListElement self) + (fromBool val)) -htmloListElementGetCompact :: - (HTMLOListElementClass self) => self -> IO Bool -htmloListElementGetCompact self - = toBool <$> - ({# call webkit_dom_htmlo_list_element_get_compact #} - (toHTMLOListElement self)) +getCompact :: + (MonadIO m, HTMLOListElementClass self) => self -> m Bool +getCompact self + = liftIO + (toBool <$> + ({# call webkit_dom_htmlo_list_element_get_compact #} + (toHTMLOListElement self))) -htmloListElementSetStart :: - (HTMLOListElementClass self) => self -> Int -> IO () -htmloListElementSetStart self val - = {# call webkit_dom_htmlo_list_element_set_start #} - (toHTMLOListElement self) - (fromIntegral val) +setStart :: + (MonadIO m, HTMLOListElementClass self) => self -> Int -> m () +setStart self val + = liftIO + ({# call webkit_dom_htmlo_list_element_set_start #} + (toHTMLOListElement self) + (fromIntegral val)) -htmloListElementGetStart :: - (HTMLOListElementClass self) => self -> IO Int -htmloListElementGetStart self - = fromIntegral <$> - ({# call webkit_dom_htmlo_list_element_get_start #} - (toHTMLOListElement self)) +getStart :: + (MonadIO m, HTMLOListElementClass self) => self -> m Int +getStart self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_htmlo_list_element_get_start #} + (toHTMLOListElement self))) -htmloListElementSetReversed :: - (HTMLOListElementClass self) => self -> Bool -> IO () -htmloListElementSetReversed self val - = {# call webkit_dom_htmlo_list_element_set_reversed #} - (toHTMLOListElement self) - (fromBool val) +setReversed :: + (MonadIO m, HTMLOListElementClass self) => self -> Bool -> m () +setReversed self val + = liftIO + ({# call webkit_dom_htmlo_list_element_set_reversed #} + (toHTMLOListElement self) + (fromBool val)) -htmloListElementGetReversed :: - (HTMLOListElementClass self) => self -> IO Bool -htmloListElementGetReversed self - = toBool <$> - ({# call webkit_dom_htmlo_list_element_get_reversed #} - (toHTMLOListElement self)) +getReversed :: + (MonadIO m, HTMLOListElementClass self) => self -> m Bool +getReversed self + = liftIO + (toBool <$> + ({# call webkit_dom_htmlo_list_element_get_reversed #} + (toHTMLOListElement self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLObjectElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLObjectElement.chs --- a/Graphics/UI/Gtk/WebKit/DOM/HTMLObjectElement.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLObjectElement.chs @@ -1,328 +1,422 @@ -module Graphics.UI.Gtk.WebKit.DOM.HTMLObjectElement - (htmlObjectElementCheckValidity, - htmlObjectElementSetCustomValidity, htmlObjectElementGetForm, - htmlObjectElementSetCode, htmlObjectElementGetCode, - htmlObjectElementSetAlign, htmlObjectElementGetAlign, - htmlObjectElementSetArchive, htmlObjectElementGetArchive, - htmlObjectElementSetBorder, htmlObjectElementGetBorder, - htmlObjectElementSetCodeBase, htmlObjectElementGetCodeBase, - htmlObjectElementSetCodeType, htmlObjectElementGetCodeType, - htmlObjectElementSetData, htmlObjectElementGetData, - htmlObjectElementSetDeclare, htmlObjectElementGetDeclare, - htmlObjectElementSetHeight, htmlObjectElementGetHeight, - htmlObjectElementSetHspace, htmlObjectElementGetHspace, - htmlObjectElementSetName, htmlObjectElementGetName, - htmlObjectElementSetStandby, htmlObjectElementGetStandby, - htmlObjectElementSetUseMap, htmlObjectElementGetUseMap, - htmlObjectElementSetVspace, htmlObjectElementGetVspace, - htmlObjectElementSetWidth, htmlObjectElementGetWidth, - htmlObjectElementGetWillValidate, htmlObjectElementGetValidity, - htmlObjectElementGetValidationMessage, - htmlObjectElementGetContentDocument, HTMLObjectElement, - HTMLObjectElementClass, castToHTMLObjectElement, - gTypeHTMLObjectElement, toHTMLObjectElement) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.HTMLObjectElement( +checkValidity, +setCustomValidity, +getForm, +setCode, +getCode, +setAlign, +getAlign, +setArchive, +getArchive, +setBorder, +getBorder, +setCodeBase, +getCodeBase, +setCodeType, +getCodeType, +setData, +getData, +setDeclare, +getDeclare, +setHeight, +getHeight, +setHspace, +getHspace, +setName, +getName, +setStandby, +getStandby, +setUseMap, +getUseMap, +setVspace, +getVspace, +setWidth, +getWidth, +getWillValidate, +getValidity, +getValidationMessage, +getContentDocument, +HTMLObjectElement, +castToHTMLObjectElement, +gTypeHTMLObjectElement, +HTMLObjectElementClass, +toHTMLObjectElement, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -htmlObjectElementCheckValidity :: - (HTMLObjectElementClass self) => self -> IO Bool -htmlObjectElementCheckValidity self - = toBool <$> - ({# call webkit_dom_html_object_element_check_validity #} - (toHTMLObjectElement self)) +checkValidity :: + (MonadIO m, HTMLObjectElementClass self) => self -> m Bool +checkValidity self + = liftIO + (toBool <$> + ({# call webkit_dom_html_object_element_check_validity #} + (toHTMLObjectElement self))) -htmlObjectElementSetCustomValidity :: - (HTMLObjectElementClass self) => self -> String -> IO () -htmlObjectElementSetCustomValidity self error - = withUTFString error $ - \ errorPtr -> - {# call webkit_dom_html_object_element_set_custom_validity #} - (toHTMLObjectElement self) - errorPtr +setCustomValidity :: + (MonadIO m, HTMLObjectElementClass self, GlibString string) => + self -> (Maybe string) -> m () +setCustomValidity self error + = liftIO + (maybeWith withUTFString error $ + \ errorPtr -> + {# call webkit_dom_html_object_element_set_custom_validity #} + (toHTMLObjectElement self) + errorPtr) -htmlObjectElementGetForm :: - (HTMLObjectElementClass self) => self -> IO (Maybe HTMLFormElement) -htmlObjectElementGetForm self - = maybeNull (makeNewGObject mkHTMLFormElement) - ({# call webkit_dom_html_object_element_get_form #} - (toHTMLObjectElement self)) +getForm :: + (MonadIO m, HTMLObjectElementClass self) => + self -> m (Maybe HTMLFormElement) +getForm self + = liftIO + (maybeNull (makeNewGObject mkHTMLFormElement) + ({# call webkit_dom_html_object_element_get_form #} + (toHTMLObjectElement self))) -htmlObjectElementSetCode :: - (HTMLObjectElementClass self) => self -> String -> IO () -htmlObjectElementSetCode self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_object_element_set_code #} - (toHTMLObjectElement self) - valPtr +setCode :: + (MonadIO m, HTMLObjectElementClass self, GlibString string) => + self -> string -> m () +setCode self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_object_element_set_code #} + (toHTMLObjectElement self) + valPtr) -htmlObjectElementGetCode :: - (HTMLObjectElementClass self) => self -> IO String -htmlObjectElementGetCode self - = ({# call webkit_dom_html_object_element_get_code #} - (toHTMLObjectElement self)) - >>= - readUTFString +getCode :: + (MonadIO m, HTMLObjectElementClass self, GlibString string) => + self -> m string +getCode self + = liftIO + (({# call webkit_dom_html_object_element_get_code #} + (toHTMLObjectElement self)) + >>= + readUTFString) -htmlObjectElementSetAlign :: - (HTMLObjectElementClass self) => self -> String -> IO () -htmlObjectElementSetAlign self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_object_element_set_align #} - (toHTMLObjectElement self) - valPtr +setAlign :: + (MonadIO m, HTMLObjectElementClass self, GlibString string) => + self -> string -> m () +setAlign self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_object_element_set_align #} + (toHTMLObjectElement self) + valPtr) -htmlObjectElementGetAlign :: - (HTMLObjectElementClass self) => self -> IO String -htmlObjectElementGetAlign self - = ({# call webkit_dom_html_object_element_get_align #} - (toHTMLObjectElement self)) - >>= - readUTFString +getAlign :: + (MonadIO m, HTMLObjectElementClass self, GlibString string) => + self -> m string +getAlign self + = liftIO + (({# call webkit_dom_html_object_element_get_align #} + (toHTMLObjectElement self)) + >>= + readUTFString) -htmlObjectElementSetArchive :: - (HTMLObjectElementClass self) => self -> String -> IO () -htmlObjectElementSetArchive self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_object_element_set_archive #} - (toHTMLObjectElement self) - valPtr +setArchive :: + (MonadIO m, HTMLObjectElementClass self, GlibString string) => + self -> string -> m () +setArchive self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_object_element_set_archive #} + (toHTMLObjectElement self) + valPtr) -htmlObjectElementGetArchive :: - (HTMLObjectElementClass self) => self -> IO String -htmlObjectElementGetArchive self - = ({# call webkit_dom_html_object_element_get_archive #} - (toHTMLObjectElement self)) - >>= - readUTFString +getArchive :: + (MonadIO m, HTMLObjectElementClass self, GlibString string) => + self -> m string +getArchive self + = liftIO + (({# call webkit_dom_html_object_element_get_archive #} + (toHTMLObjectElement self)) + >>= + readUTFString) -htmlObjectElementSetBorder :: - (HTMLObjectElementClass self) => self -> String -> IO () -htmlObjectElementSetBorder self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_object_element_set_border #} - (toHTMLObjectElement self) - valPtr +setBorder :: + (MonadIO m, HTMLObjectElementClass self, GlibString string) => + self -> string -> m () +setBorder self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_object_element_set_border #} + (toHTMLObjectElement self) + valPtr) -htmlObjectElementGetBorder :: - (HTMLObjectElementClass self) => self -> IO String -htmlObjectElementGetBorder self - = ({# call webkit_dom_html_object_element_get_border #} - (toHTMLObjectElement self)) - >>= - readUTFString +getBorder :: + (MonadIO m, HTMLObjectElementClass self, GlibString string) => + self -> m string +getBorder self + = liftIO + (({# call webkit_dom_html_object_element_get_border #} + (toHTMLObjectElement self)) + >>= + readUTFString) -htmlObjectElementSetCodeBase :: - (HTMLObjectElementClass self) => self -> String -> IO () -htmlObjectElementSetCodeBase self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_object_element_set_code_base #} - (toHTMLObjectElement self) - valPtr +setCodeBase :: + (MonadIO m, HTMLObjectElementClass self, GlibString string) => + self -> string -> m () +setCodeBase self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_object_element_set_code_base #} + (toHTMLObjectElement self) + valPtr) -htmlObjectElementGetCodeBase :: - (HTMLObjectElementClass self) => self -> IO String -htmlObjectElementGetCodeBase self - = ({# call webkit_dom_html_object_element_get_code_base #} - (toHTMLObjectElement self)) - >>= - readUTFString +getCodeBase :: + (MonadIO m, HTMLObjectElementClass self, GlibString string) => + self -> m string +getCodeBase self + = liftIO + (({# call webkit_dom_html_object_element_get_code_base #} + (toHTMLObjectElement self)) + >>= + readUTFString) -htmlObjectElementSetCodeType :: - (HTMLObjectElementClass self) => self -> String -> IO () -htmlObjectElementSetCodeType self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_object_element_set_code_type #} - (toHTMLObjectElement self) - valPtr +setCodeType :: + (MonadIO m, HTMLObjectElementClass self, GlibString string) => + self -> string -> m () +setCodeType self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_object_element_set_code_type #} + (toHTMLObjectElement self) + valPtr) -htmlObjectElementGetCodeType :: - (HTMLObjectElementClass self) => self -> IO String -htmlObjectElementGetCodeType self - = ({# call webkit_dom_html_object_element_get_code_type #} - (toHTMLObjectElement self)) - >>= - readUTFString +getCodeType :: + (MonadIO m, HTMLObjectElementClass self, GlibString string) => + self -> m string +getCodeType self + = liftIO + (({# call webkit_dom_html_object_element_get_code_type #} + (toHTMLObjectElement self)) + >>= + readUTFString) -htmlObjectElementSetData :: - (HTMLObjectElementClass self) => self -> String -> IO () -htmlObjectElementSetData self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_object_element_set_data #} - (toHTMLObjectElement self) - valPtr +setData :: + (MonadIO m, HTMLObjectElementClass self, GlibString string) => + self -> string -> m () +setData self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_object_element_set_data #} + (toHTMLObjectElement self) + valPtr) -htmlObjectElementGetData :: - (HTMLObjectElementClass self) => self -> IO String -htmlObjectElementGetData self - = ({# call webkit_dom_html_object_element_get_data #} - (toHTMLObjectElement self)) - >>= - readUTFString +getData :: + (MonadIO m, HTMLObjectElementClass self, GlibString string) => + self -> m string +getData self + = liftIO + (({# call webkit_dom_html_object_element_get_data #} + (toHTMLObjectElement self)) + >>= + readUTFString) -htmlObjectElementSetDeclare :: - (HTMLObjectElementClass self) => self -> Bool -> IO () -htmlObjectElementSetDeclare self val - = {# call webkit_dom_html_object_element_set_declare #} - (toHTMLObjectElement self) - (fromBool val) +setDeclare :: + (MonadIO m, HTMLObjectElementClass self) => self -> Bool -> m () +setDeclare self val + = liftIO + ({# call webkit_dom_html_object_element_set_declare #} + (toHTMLObjectElement self) + (fromBool val)) -htmlObjectElementGetDeclare :: - (HTMLObjectElementClass self) => self -> IO Bool -htmlObjectElementGetDeclare self - = toBool <$> - ({# call webkit_dom_html_object_element_get_declare #} - (toHTMLObjectElement self)) +getDeclare :: + (MonadIO m, HTMLObjectElementClass self) => self -> m Bool +getDeclare self + = liftIO + (toBool <$> + ({# call webkit_dom_html_object_element_get_declare #} + (toHTMLObjectElement self))) -htmlObjectElementSetHeight :: - (HTMLObjectElementClass self) => self -> String -> IO () -htmlObjectElementSetHeight self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_object_element_set_height #} - (toHTMLObjectElement self) - valPtr +setHeight :: + (MonadIO m, HTMLObjectElementClass self, GlibString string) => + self -> string -> m () +setHeight self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_object_element_set_height #} + (toHTMLObjectElement self) + valPtr) -htmlObjectElementGetHeight :: - (HTMLObjectElementClass self) => self -> IO String -htmlObjectElementGetHeight self - = ({# call webkit_dom_html_object_element_get_height #} - (toHTMLObjectElement self)) - >>= - readUTFString +getHeight :: + (MonadIO m, HTMLObjectElementClass self, GlibString string) => + self -> m string +getHeight self + = liftIO + (({# call webkit_dom_html_object_element_get_height #} + (toHTMLObjectElement self)) + >>= + readUTFString) -htmlObjectElementSetHspace :: - (HTMLObjectElementClass self) => self -> Int -> IO () -htmlObjectElementSetHspace self val - = {# call webkit_dom_html_object_element_set_hspace #} - (toHTMLObjectElement self) - (fromIntegral val) +setHspace :: + (MonadIO m, HTMLObjectElementClass self) => self -> Int -> m () +setHspace self val + = liftIO + ({# call webkit_dom_html_object_element_set_hspace #} + (toHTMLObjectElement self) + (fromIntegral val)) -htmlObjectElementGetHspace :: - (HTMLObjectElementClass self) => self -> IO Int -htmlObjectElementGetHspace self - = fromIntegral <$> - ({# call webkit_dom_html_object_element_get_hspace #} - (toHTMLObjectElement self)) +getHspace :: + (MonadIO m, HTMLObjectElementClass self) => self -> m Int +getHspace self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_object_element_get_hspace #} + (toHTMLObjectElement self))) -htmlObjectElementSetName :: - (HTMLObjectElementClass self) => self -> String -> IO () -htmlObjectElementSetName self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_object_element_set_name #} - (toHTMLObjectElement self) - valPtr +setName :: + (MonadIO m, HTMLObjectElementClass self, GlibString string) => + self -> string -> m () +setName self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_object_element_set_name #} + (toHTMLObjectElement self) + valPtr) -htmlObjectElementGetName :: - (HTMLObjectElementClass self) => self -> IO String -htmlObjectElementGetName self - = ({# call webkit_dom_html_object_element_get_name #} - (toHTMLObjectElement self)) - >>= - readUTFString +getName :: + (MonadIO m, HTMLObjectElementClass self, GlibString string) => + self -> m string +getName self + = liftIO + (({# call webkit_dom_html_object_element_get_name #} + (toHTMLObjectElement self)) + >>= + readUTFString) -htmlObjectElementSetStandby :: - (HTMLObjectElementClass self) => self -> String -> IO () -htmlObjectElementSetStandby self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_object_element_set_standby #} - (toHTMLObjectElement self) - valPtr +setStandby :: + (MonadIO m, HTMLObjectElementClass self, GlibString string) => + self -> string -> m () +setStandby self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_object_element_set_standby #} + (toHTMLObjectElement self) + valPtr) -htmlObjectElementGetStandby :: - (HTMLObjectElementClass self) => self -> IO String -htmlObjectElementGetStandby self - = ({# call webkit_dom_html_object_element_get_standby #} - (toHTMLObjectElement self)) - >>= - readUTFString +getStandby :: + (MonadIO m, HTMLObjectElementClass self, GlibString string) => + self -> m string +getStandby self + = liftIO + (({# call webkit_dom_html_object_element_get_standby #} + (toHTMLObjectElement self)) + >>= + readUTFString) -htmlObjectElementSetUseMap :: - (HTMLObjectElementClass self) => self -> String -> IO () -htmlObjectElementSetUseMap self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_object_element_set_use_map #} - (toHTMLObjectElement self) - valPtr +setUseMap :: + (MonadIO m, HTMLObjectElementClass self, GlibString string) => + self -> string -> m () +setUseMap self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_object_element_set_use_map #} + (toHTMLObjectElement self) + valPtr) -htmlObjectElementGetUseMap :: - (HTMLObjectElementClass self) => self -> IO String -htmlObjectElementGetUseMap self - = ({# call webkit_dom_html_object_element_get_use_map #} - (toHTMLObjectElement self)) - >>= - readUTFString +getUseMap :: + (MonadIO m, HTMLObjectElementClass self, GlibString string) => + self -> m string +getUseMap self + = liftIO + (({# call webkit_dom_html_object_element_get_use_map #} + (toHTMLObjectElement self)) + >>= + readUTFString) -htmlObjectElementSetVspace :: - (HTMLObjectElementClass self) => self -> Int -> IO () -htmlObjectElementSetVspace self val - = {# call webkit_dom_html_object_element_set_vspace #} - (toHTMLObjectElement self) - (fromIntegral val) +setVspace :: + (MonadIO m, HTMLObjectElementClass self) => self -> Int -> m () +setVspace self val + = liftIO + ({# call webkit_dom_html_object_element_set_vspace #} + (toHTMLObjectElement self) + (fromIntegral val)) -htmlObjectElementGetVspace :: - (HTMLObjectElementClass self) => self -> IO Int -htmlObjectElementGetVspace self - = fromIntegral <$> - ({# call webkit_dom_html_object_element_get_vspace #} - (toHTMLObjectElement self)) +getVspace :: + (MonadIO m, HTMLObjectElementClass self) => self -> m Int +getVspace self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_object_element_get_vspace #} + (toHTMLObjectElement self))) -htmlObjectElementSetWidth :: - (HTMLObjectElementClass self) => self -> String -> IO () -htmlObjectElementSetWidth self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_object_element_set_width #} - (toHTMLObjectElement self) - valPtr +setWidth :: + (MonadIO m, HTMLObjectElementClass self, GlibString string) => + self -> string -> m () +setWidth self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_object_element_set_width #} + (toHTMLObjectElement self) + valPtr) -htmlObjectElementGetWidth :: - (HTMLObjectElementClass self) => self -> IO String -htmlObjectElementGetWidth self - = ({# call webkit_dom_html_object_element_get_width #} - (toHTMLObjectElement self)) - >>= - readUTFString +getWidth :: + (MonadIO m, HTMLObjectElementClass self, GlibString string) => + self -> m string +getWidth self + = liftIO + (({# call webkit_dom_html_object_element_get_width #} + (toHTMLObjectElement self)) + >>= + readUTFString) -htmlObjectElementGetWillValidate :: - (HTMLObjectElementClass self) => self -> IO Bool -htmlObjectElementGetWillValidate self - = toBool <$> - ({# call webkit_dom_html_object_element_get_will_validate #} - (toHTMLObjectElement self)) +getWillValidate :: + (MonadIO m, HTMLObjectElementClass self) => self -> m Bool +getWillValidate self + = liftIO + (toBool <$> + ({# call webkit_dom_html_object_element_get_will_validate #} + (toHTMLObjectElement self))) -htmlObjectElementGetValidity :: - (HTMLObjectElementClass self) => self -> IO (Maybe ValidityState) -htmlObjectElementGetValidity self - = maybeNull (makeNewGObject mkValidityState) - ({# call webkit_dom_html_object_element_get_validity #} - (toHTMLObjectElement self)) +getValidity :: + (MonadIO m, HTMLObjectElementClass self) => + self -> m (Maybe ValidityState) +getValidity self + = liftIO + (maybeNull (makeNewGObject mkValidityState) + ({# call webkit_dom_html_object_element_get_validity #} + (toHTMLObjectElement self))) -htmlObjectElementGetValidationMessage :: - (HTMLObjectElementClass self) => self -> IO String -htmlObjectElementGetValidationMessage self - = ({# call webkit_dom_html_object_element_get_validation_message #} - (toHTMLObjectElement self)) - >>= - readUTFString +getValidationMessage :: + (MonadIO m, HTMLObjectElementClass self, GlibString string) => + self -> m string +getValidationMessage self + = liftIO + (({# call webkit_dom_html_object_element_get_validation_message #} + (toHTMLObjectElement self)) + >>= + readUTFString) -htmlObjectElementGetContentDocument :: - (HTMLObjectElementClass self) => self -> IO (Maybe Document) -htmlObjectElementGetContentDocument self - = maybeNull (makeNewGObject mkDocument) - ({# call webkit_dom_html_object_element_get_content_document #} - (toHTMLObjectElement self)) +getContentDocument :: + (MonadIO m, HTMLObjectElementClass self) => + self -> m (Maybe Document) +getContentDocument self + = liftIO + (maybeNull (makeNewGObject mkDocument) + ({# call webkit_dom_html_object_element_get_content_document #} + (toHTMLObjectElement self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLOptGroupElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLOptGroupElement.chs --- a/Graphics/UI/Gtk/WebKit/DOM/HTMLOptGroupElement.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLOptGroupElement.chs @@ -1,44 +1,62 @@ -module Graphics.UI.Gtk.WebKit.DOM.HTMLOptGroupElement - (htmlOptGroupElementSetDisabled, htmlOptGroupElementGetDisabled, - htmlOptGroupElementSetLabel, htmlOptGroupElementGetLabel, - HTMLOptGroupElement, HTMLOptGroupElementClass, - castToHTMLOptGroupElement, gTypeHTMLOptGroupElement, - toHTMLOptGroupElement) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.HTMLOptGroupElement( +setDisabled, +getDisabled, +setLabel, +getLabel, +HTMLOptGroupElement, +castToHTMLOptGroupElement, +gTypeHTMLOptGroupElement, +HTMLOptGroupElementClass, +toHTMLOptGroupElement, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -htmlOptGroupElementSetDisabled :: - (HTMLOptGroupElementClass self) => self -> Bool -> IO () -htmlOptGroupElementSetDisabled self val - = {# call webkit_dom_html_opt_group_element_set_disabled #} - (toHTMLOptGroupElement self) - (fromBool val) +setDisabled :: + (MonadIO m, HTMLOptGroupElementClass self) => self -> Bool -> m () +setDisabled self val + = liftIO + ({# call webkit_dom_html_opt_group_element_set_disabled #} + (toHTMLOptGroupElement self) + (fromBool val)) -htmlOptGroupElementGetDisabled :: - (HTMLOptGroupElementClass self) => self -> IO Bool -htmlOptGroupElementGetDisabled self - = toBool <$> - ({# call webkit_dom_html_opt_group_element_get_disabled #} - (toHTMLOptGroupElement self)) +getDisabled :: + (MonadIO m, HTMLOptGroupElementClass self) => self -> m Bool +getDisabled self + = liftIO + (toBool <$> + ({# call webkit_dom_html_opt_group_element_get_disabled #} + (toHTMLOptGroupElement self))) -htmlOptGroupElementSetLabel :: - (HTMLOptGroupElementClass self) => self -> String -> IO () -htmlOptGroupElementSetLabel self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_opt_group_element_set_label #} - (toHTMLOptGroupElement self) - valPtr +setLabel :: + (MonadIO m, HTMLOptGroupElementClass self, GlibString string) => + self -> string -> m () +setLabel self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_opt_group_element_set_label #} + (toHTMLOptGroupElement self) + valPtr) -htmlOptGroupElementGetLabel :: - (HTMLOptGroupElementClass self) => self -> IO String -htmlOptGroupElementGetLabel self - = ({# call webkit_dom_html_opt_group_element_get_label #} - (toHTMLOptGroupElement self)) - >>= - readUTFString +getLabel :: + (MonadIO m, HTMLOptGroupElementClass self, GlibString string) => + self -> m string +getLabel self + = liftIO + (({# call webkit_dom_html_opt_group_element_get_label #} + (toHTMLOptGroupElement self)) + >>= + readUTFString) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLOptionElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLOptionElement.chs --- a/Graphics/UI/Gtk/WebKit/DOM/HTMLOptionElement.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLOptionElement.chs @@ -1,115 +1,151 @@ -module Graphics.UI.Gtk.WebKit.DOM.HTMLOptionElement - (htmlOptionElementSetDisabled, htmlOptionElementGetDisabled, - htmlOptionElementGetForm, htmlOptionElementSetLabel, - htmlOptionElementGetLabel, htmlOptionElementSetDefaultSelected, - htmlOptionElementGetDefaultSelected, htmlOptionElementSetSelected, - htmlOptionElementGetSelected, htmlOptionElementSetValue, - htmlOptionElementGetValue, htmlOptionElementGetText, - htmlOptionElementGetIndex, HTMLOptionElement, - HTMLOptionElementClass, castToHTMLOptionElement, - gTypeHTMLOptionElement, toHTMLOptionElement) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.HTMLOptionElement( +setDisabled, +getDisabled, +getForm, +setLabel, +getLabel, +setDefaultSelected, +getDefaultSelected, +setSelected, +getSelected, +setValue, +getValue, +getText, +getIndex, +HTMLOptionElement, +castToHTMLOptionElement, +gTypeHTMLOptionElement, +HTMLOptionElementClass, +toHTMLOptionElement, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -htmlOptionElementSetDisabled :: - (HTMLOptionElementClass self) => self -> Bool -> IO () -htmlOptionElementSetDisabled self val - = {# call webkit_dom_html_option_element_set_disabled #} - (toHTMLOptionElement self) - (fromBool val) +setDisabled :: + (MonadIO m, HTMLOptionElementClass self) => self -> Bool -> m () +setDisabled self val + = liftIO + ({# call webkit_dom_html_option_element_set_disabled #} + (toHTMLOptionElement self) + (fromBool val)) -htmlOptionElementGetDisabled :: - (HTMLOptionElementClass self) => self -> IO Bool -htmlOptionElementGetDisabled self - = toBool <$> - ({# call webkit_dom_html_option_element_get_disabled #} - (toHTMLOptionElement self)) +getDisabled :: + (MonadIO m, HTMLOptionElementClass self) => self -> m Bool +getDisabled self + = liftIO + (toBool <$> + ({# call webkit_dom_html_option_element_get_disabled #} + (toHTMLOptionElement self))) -htmlOptionElementGetForm :: - (HTMLOptionElementClass self) => self -> IO (Maybe HTMLFormElement) -htmlOptionElementGetForm self - = maybeNull (makeNewGObject mkHTMLFormElement) - ({# call webkit_dom_html_option_element_get_form #} - (toHTMLOptionElement self)) +getForm :: + (MonadIO m, HTMLOptionElementClass self) => + self -> m (Maybe HTMLFormElement) +getForm self + = liftIO + (maybeNull (makeNewGObject mkHTMLFormElement) + ({# call webkit_dom_html_option_element_get_form #} + (toHTMLOptionElement self))) -htmlOptionElementSetLabel :: - (HTMLOptionElementClass self) => self -> String -> IO () -htmlOptionElementSetLabel self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_option_element_set_label #} - (toHTMLOptionElement self) - valPtr +setLabel :: + (MonadIO m, HTMLOptionElementClass self, GlibString string) => + self -> string -> m () +setLabel self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_option_element_set_label #} + (toHTMLOptionElement self) + valPtr) -htmlOptionElementGetLabel :: - (HTMLOptionElementClass self) => self -> IO String -htmlOptionElementGetLabel self - = ({# call webkit_dom_html_option_element_get_label #} - (toHTMLOptionElement self)) - >>= - readUTFString +getLabel :: + (MonadIO m, HTMLOptionElementClass self, GlibString string) => + self -> m string +getLabel self + = liftIO + (({# call webkit_dom_html_option_element_get_label #} + (toHTMLOptionElement self)) + >>= + readUTFString) -htmlOptionElementSetDefaultSelected :: - (HTMLOptionElementClass self) => self -> Bool -> IO () -htmlOptionElementSetDefaultSelected self val - = {# call webkit_dom_html_option_element_set_default_selected #} - (toHTMLOptionElement self) - (fromBool val) +setDefaultSelected :: + (MonadIO m, HTMLOptionElementClass self) => self -> Bool -> m () +setDefaultSelected self val + = liftIO + ({# call webkit_dom_html_option_element_set_default_selected #} + (toHTMLOptionElement self) + (fromBool val)) -htmlOptionElementGetDefaultSelected :: - (HTMLOptionElementClass self) => self -> IO Bool -htmlOptionElementGetDefaultSelected self - = toBool <$> - ({# call webkit_dom_html_option_element_get_default_selected #} - (toHTMLOptionElement self)) +getDefaultSelected :: + (MonadIO m, HTMLOptionElementClass self) => self -> m Bool +getDefaultSelected self + = liftIO + (toBool <$> + ({# call webkit_dom_html_option_element_get_default_selected #} + (toHTMLOptionElement self))) -htmlOptionElementSetSelected :: - (HTMLOptionElementClass self) => self -> Bool -> IO () -htmlOptionElementSetSelected self val - = {# call webkit_dom_html_option_element_set_selected #} - (toHTMLOptionElement self) - (fromBool val) +setSelected :: + (MonadIO m, HTMLOptionElementClass self) => self -> Bool -> m () +setSelected self val + = liftIO + ({# call webkit_dom_html_option_element_set_selected #} + (toHTMLOptionElement self) + (fromBool val)) -htmlOptionElementGetSelected :: - (HTMLOptionElementClass self) => self -> IO Bool -htmlOptionElementGetSelected self - = toBool <$> - ({# call webkit_dom_html_option_element_get_selected #} - (toHTMLOptionElement self)) +getSelected :: + (MonadIO m, HTMLOptionElementClass self) => self -> m Bool +getSelected self + = liftIO + (toBool <$> + ({# call webkit_dom_html_option_element_get_selected #} + (toHTMLOptionElement self))) -htmlOptionElementSetValue :: - (HTMLOptionElementClass self) => self -> String -> IO () -htmlOptionElementSetValue self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_option_element_set_value #} - (toHTMLOptionElement self) - valPtr +setValue :: + (MonadIO m, HTMLOptionElementClass self, GlibString string) => + self -> string -> m () +setValue self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_option_element_set_value #} + (toHTMLOptionElement self) + valPtr) -htmlOptionElementGetValue :: - (HTMLOptionElementClass self) => self -> IO String -htmlOptionElementGetValue self - = ({# call webkit_dom_html_option_element_get_value #} - (toHTMLOptionElement self)) - >>= - readUTFString +getValue :: + (MonadIO m, HTMLOptionElementClass self, GlibString string) => + self -> m string +getValue self + = liftIO + (({# call webkit_dom_html_option_element_get_value #} + (toHTMLOptionElement self)) + >>= + readUTFString) -htmlOptionElementGetText :: - (HTMLOptionElementClass self) => self -> IO String -htmlOptionElementGetText self - = ({# call webkit_dom_html_option_element_get_text #} - (toHTMLOptionElement self)) - >>= - readUTFString +getText :: + (MonadIO m, HTMLOptionElementClass self, GlibString string) => + self -> m string +getText self + = liftIO + (({# call webkit_dom_html_option_element_get_text #} + (toHTMLOptionElement self)) + >>= + readUTFString) -htmlOptionElementGetIndex :: - (HTMLOptionElementClass self) => self -> IO Int -htmlOptionElementGetIndex self - = fromIntegral <$> - ({# call webkit_dom_html_option_element_get_index #} - (toHTMLOptionElement self)) +getIndex :: + (MonadIO m, HTMLOptionElementClass self) => self -> m Int +getIndex self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_option_element_get_index #} + (toHTMLOptionElement self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLOptionsCollection.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLOptionsCollection.chs --- a/Graphics/UI/Gtk/WebKit/DOM/HTMLOptionsCollection.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLOptionsCollection.chs @@ -1,43 +1,90 @@ -module Graphics.UI.Gtk.WebKit.DOM.HTMLOptionsCollection - ( +module Graphics.UI.Gtk.WebKit.DOM.HTMLOptionsCollection( #if WEBKIT_CHECK_VERSION(2,2,2) - htmlOptionsCollectionNamedItem, +namedItem, #endif - htmlOptionsCollectionSetSelectedIndex, - htmlOptionsCollectionGetSelectedIndex, HTMLOptionsCollection, - HTMLOptionsCollectionClass, castToHTMLOptionsCollection, - gTypeHTMLOptionsCollection, toHTMLOptionsCollection) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +#if WEBKIT_CHECK_VERSION(99,0,0) +addBefore, +add, +#endif +setSelectedIndex, +getSelectedIndex, +HTMLOptionsCollection, +castToHTMLOptionsCollection, +gTypeHTMLOptionsCollection, +HTMLOptionsCollectionClass, +toHTMLOptionsCollection, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + + +#if WEBKIT_CHECK_VERSION(2,2,2) +namedItem :: + (MonadIO m, HTMLOptionsCollectionClass self, GlibString string) => + self -> string -> m (Maybe Node) +namedItem self name + = liftIO + (maybeNull (makeNewGObject mkNode) + (withUTFString name $ + \ namePtr -> + {# call webkit_dom_html_options_collection_named_item #} + (toHTMLOptionsCollection self) + namePtr)) +#endif + +#if WEBKIT_CHECK_VERSION(99,0,0) +addBefore :: + (MonadIO m, HTMLOptionsCollectionClass self, + HTMLElementClass element, HTMLElementClass before) => + self -> Maybe element -> Maybe before -> m () +addBefore self element before + = liftIO + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_html_options_collection_add #} + (toHTMLOptionsCollection self) + (maybe (HTMLElement nullForeignPtr) toHTMLElement element) + (maybe (HTMLElement nullForeignPtr) toHTMLElement before) + errorPtr_) -#if WEBKIT_CHECK_VERSION(2,2,2) -htmlOptionsCollectionNamedItem :: - (HTMLOptionsCollectionClass self) => - self -> String -> IO (Maybe Node) -htmlOptionsCollectionNamedItem self name - = maybeNull (makeNewGObject mkNode) - (withUTFString name $ - \ namePtr -> - {# call webkit_dom_html_options_collection_named_item #} +add :: + (MonadIO m, HTMLOptionsCollectionClass self, + HTMLElementClass element) => + self -> Maybe element -> Int -> m () +add self element index + = liftIO + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_html_options_collection_add #} (toHTMLOptionsCollection self) - namePtr) + (maybe (HTMLElement nullForeignPtr) toHTMLElement element) + (fromIntegral index) + errorPtr_) #endif - -htmlOptionsCollectionSetSelectedIndex :: - (HTMLOptionsCollectionClass self) => self -> Int -> IO () -htmlOptionsCollectionSetSelectedIndex self val - = {# call webkit_dom_html_options_collection_set_selected_index #} - (toHTMLOptionsCollection self) - (fromIntegral val) -htmlOptionsCollectionGetSelectedIndex :: - (HTMLOptionsCollectionClass self) => self -> IO Int -htmlOptionsCollectionGetSelectedIndex self - = fromIntegral <$> - ({# call webkit_dom_html_options_collection_get_selected_index #} - (toHTMLOptionsCollection self)) +setSelectedIndex :: + (MonadIO m, HTMLOptionsCollectionClass self) => self -> Int -> m () +setSelectedIndex self val + = liftIO + ({# call webkit_dom_html_options_collection_set_selected_index #} + (toHTMLOptionsCollection self) + (fromIntegral val)) + +getSelectedIndex :: + (MonadIO m, HTMLOptionsCollectionClass self) => self -> m Int +getSelectedIndex self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_options_collection_get_selected_index #} + (toHTMLOptionsCollection self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLParagraphElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLParagraphElement.chs --- a/Graphics/UI/Gtk/WebKit/DOM/HTMLParagraphElement.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLParagraphElement.chs @@ -1,29 +1,44 @@ -module Graphics.UI.Gtk.WebKit.DOM.HTMLParagraphElement - (htmlParagraphElementSetAlign, htmlParagraphElementGetAlign, - HTMLParagraphElement, HTMLParagraphElementClass, - castToHTMLParagraphElement, gTypeHTMLParagraphElement, - toHTMLParagraphElement) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.HTMLParagraphElement( +setAlign, +getAlign, +HTMLParagraphElement, +castToHTMLParagraphElement, +gTypeHTMLParagraphElement, +HTMLParagraphElementClass, +toHTMLParagraphElement, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -htmlParagraphElementSetAlign :: - (HTMLParagraphElementClass self) => self -> String -> IO () -htmlParagraphElementSetAlign self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_paragraph_element_set_align #} - (toHTMLParagraphElement self) - valPtr +setAlign :: + (MonadIO m, HTMLParagraphElementClass self, GlibString string) => + self -> string -> m () +setAlign self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_paragraph_element_set_align #} + (toHTMLParagraphElement self) + valPtr) -htmlParagraphElementGetAlign :: - (HTMLParagraphElementClass self) => self -> IO String -htmlParagraphElementGetAlign self - = ({# call webkit_dom_html_paragraph_element_get_align #} - (toHTMLParagraphElement self)) - >>= - readUTFString +getAlign :: + (MonadIO m, HTMLParagraphElementClass self, GlibString string) => + self -> m string +getAlign self + = liftIO + (({# call webkit_dom_html_paragraph_element_get_align #} + (toHTMLParagraphElement self)) + >>= + readUTFString) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLParamElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLParamElement.chs --- a/Graphics/UI/Gtk/WebKit/DOM/HTMLParamElement.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLParamElement.chs @@ -1,64 +1,90 @@ -module Graphics.UI.Gtk.WebKit.DOM.HTMLParamElement - (htmlParamElementSetName, htmlParamElementGetName, - htmlParamElementSetValue, htmlParamElementGetValue, - htmlParamElementSetValueType, htmlParamElementGetValueType, - HTMLParamElement, HTMLParamElementClass, castToHTMLParamElement, - gTypeHTMLParamElement, toHTMLParamElement) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.HTMLParamElement( +setName, +getName, +setValue, +getValue, +setValueType, +getValueType, +HTMLParamElement, +castToHTMLParamElement, +gTypeHTMLParamElement, +HTMLParamElementClass, +toHTMLParamElement, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -htmlParamElementSetName :: - (HTMLParamElementClass self) => self -> String -> IO () -htmlParamElementSetName self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_param_element_set_name #} - (toHTMLParamElement self) - valPtr +setName :: + (MonadIO m, HTMLParamElementClass self, GlibString string) => + self -> string -> m () +setName self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_param_element_set_name #} + (toHTMLParamElement self) + valPtr) -htmlParamElementGetName :: - (HTMLParamElementClass self) => self -> IO String -htmlParamElementGetName self - = ({# call webkit_dom_html_param_element_get_name #} - (toHTMLParamElement self)) - >>= - readUTFString +getName :: + (MonadIO m, HTMLParamElementClass self, GlibString string) => + self -> m string +getName self + = liftIO + (({# call webkit_dom_html_param_element_get_name #} + (toHTMLParamElement self)) + >>= + readUTFString) -htmlParamElementSetValue :: - (HTMLParamElementClass self) => self -> String -> IO () -htmlParamElementSetValue self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_param_element_set_value #} - (toHTMLParamElement self) - valPtr +setValue :: + (MonadIO m, HTMLParamElementClass self, GlibString string) => + self -> string -> m () +setValue self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_param_element_set_value #} + (toHTMLParamElement self) + valPtr) -htmlParamElementGetValue :: - (HTMLParamElementClass self) => self -> IO String -htmlParamElementGetValue self - = ({# call webkit_dom_html_param_element_get_value #} - (toHTMLParamElement self)) - >>= - readUTFString +getValue :: + (MonadIO m, HTMLParamElementClass self, GlibString string) => + self -> m string +getValue self + = liftIO + (({# call webkit_dom_html_param_element_get_value #} + (toHTMLParamElement self)) + >>= + readUTFString) -htmlParamElementSetValueType :: - (HTMLParamElementClass self) => self -> String -> IO () -htmlParamElementSetValueType self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_param_element_set_value_type #} - (toHTMLParamElement self) - valPtr +setValueType :: + (MonadIO m, HTMLParamElementClass self, GlibString string) => + self -> string -> m () +setValueType self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_param_element_set_value_type #} + (toHTMLParamElement self) + valPtr) -htmlParamElementGetValueType :: - (HTMLParamElementClass self) => self -> IO String -htmlParamElementGetValueType self - = ({# call webkit_dom_html_param_element_get_value_type #} - (toHTMLParamElement self)) - >>= - readUTFString +getValueType :: + (MonadIO m, HTMLParamElementClass self, GlibString string) => + self -> m string +getValueType self + = liftIO + (({# call webkit_dom_html_param_element_get_value_type #} + (toHTMLParamElement self)) + >>= + readUTFString) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLPreElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLPreElement.chs --- a/Graphics/UI/Gtk/WebKit/DOM/HTMLPreElement.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLPreElement.chs @@ -1,40 +1,55 @@ -module Graphics.UI.Gtk.WebKit.DOM.HTMLPreElement - (htmlPreElementSetWidth, htmlPreElementGetWidth, - htmlPreElementSetWrap, htmlPreElementGetWrap, HTMLPreElement, - HTMLPreElementClass, castToHTMLPreElement, gTypeHTMLPreElement, - toHTMLPreElement) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.HTMLPreElement( +setWidth, +getWidth, +setWrap, +getWrap, +HTMLPreElement, +castToHTMLPreElement, +gTypeHTMLPreElement, +HTMLPreElementClass, +toHTMLPreElement, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -htmlPreElementSetWidth :: - (HTMLPreElementClass self) => self -> Int -> IO () -htmlPreElementSetWidth self val - = {# call webkit_dom_html_pre_element_set_width #} - (toHTMLPreElement self) - (fromIntegral val) +setWidth :: + (MonadIO m, HTMLPreElementClass self) => self -> Int -> m () +setWidth self val + = liftIO + ({# call webkit_dom_html_pre_element_set_width #} + (toHTMLPreElement self) + (fromIntegral val)) -htmlPreElementGetWidth :: - (HTMLPreElementClass self) => self -> IO Int -htmlPreElementGetWidth self - = fromIntegral <$> - ({# call webkit_dom_html_pre_element_get_width #} - (toHTMLPreElement self)) +getWidth :: (MonadIO m, HTMLPreElementClass self) => self -> m Int +getWidth self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_pre_element_get_width #} + (toHTMLPreElement self))) -htmlPreElementSetWrap :: - (HTMLPreElementClass self) => self -> Bool -> IO () -htmlPreElementSetWrap self val - = {# call webkit_dom_html_pre_element_set_wrap #} - (toHTMLPreElement self) - (fromBool val) +setWrap :: + (MonadIO m, HTMLPreElementClass self) => self -> Bool -> m () +setWrap self val + = liftIO + ({# call webkit_dom_html_pre_element_set_wrap #} + (toHTMLPreElement self) + (fromBool val)) -htmlPreElementGetWrap :: - (HTMLPreElementClass self) => self -> IO Bool -htmlPreElementGetWrap self - = toBool <$> - ({# call webkit_dom_html_pre_element_get_wrap #} - (toHTMLPreElement self)) +getWrap :: (MonadIO m, HTMLPreElementClass self) => self -> m Bool +getWrap self + = liftIO + (toBool <$> + ({# call webkit_dom_html_pre_element_get_wrap #} + (toHTMLPreElement self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLQuoteElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLQuoteElement.chs --- a/Graphics/UI/Gtk/WebKit/DOM/HTMLQuoteElement.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLQuoteElement.chs @@ -1,28 +1,44 @@ -module Graphics.UI.Gtk.WebKit.DOM.HTMLQuoteElement - (htmlQuoteElementSetCite, htmlQuoteElementGetCite, - HTMLQuoteElement, HTMLQuoteElementClass, castToHTMLQuoteElement, - gTypeHTMLQuoteElement, toHTMLQuoteElement) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.HTMLQuoteElement( +setCite, +getCite, +HTMLQuoteElement, +castToHTMLQuoteElement, +gTypeHTMLQuoteElement, +HTMLQuoteElementClass, +toHTMLQuoteElement, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -htmlQuoteElementSetCite :: - (HTMLQuoteElementClass self) => self -> String -> IO () -htmlQuoteElementSetCite self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_quote_element_set_cite #} - (toHTMLQuoteElement self) - valPtr +setCite :: + (MonadIO m, HTMLQuoteElementClass self, GlibString string) => + self -> string -> m () +setCite self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_quote_element_set_cite #} + (toHTMLQuoteElement self) + valPtr) -htmlQuoteElementGetCite :: - (HTMLQuoteElementClass self) => self -> IO String -htmlQuoteElementGetCite self - = ({# call webkit_dom_html_quote_element_get_cite #} - (toHTMLQuoteElement self)) - >>= - readUTFString +getCite :: + (MonadIO m, HTMLQuoteElementClass self, GlibString string) => + self -> m string +getCite self + = liftIO + (({# call webkit_dom_html_quote_element_get_cite #} + (toHTMLQuoteElement self)) + >>= + readUTFString) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLScriptElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLScriptElement.chs --- a/Graphics/UI/Gtk/WebKit/DOM/HTMLScriptElement.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLScriptElement.chs @@ -1,170 +1,222 @@ -module Graphics.UI.Gtk.WebKit.DOM.HTMLScriptElement - (htmlScriptElementSetText, htmlScriptElementGetText, - htmlScriptElementSetHtmlFor, htmlScriptElementGetHtmlFor, - htmlScriptElementSetEvent, htmlScriptElementGetEvent, - htmlScriptElementSetCharset, htmlScriptElementGetCharset, - htmlScriptElementSetAsync, htmlScriptElementGetAsync, - htmlScriptElementSetDefer, htmlScriptElementGetDefer, - htmlScriptElementSetSrc, htmlScriptElementGetSrc, -#if WEBKIT_CHECK_VERSION(1,10,0) - htmlScriptElementSetCrossOrigin, htmlScriptElementGetCrossOrigin, - htmlScriptElementSetNonce, htmlScriptElementGetNonce, +module Graphics.UI.Gtk.WebKit.DOM.HTMLScriptElement( +setText, +getText, +setHtmlFor, +getHtmlFor, +setEvent, +getEvent, +setCharset, +getCharset, +setAsync, +getAsync, +setDefer, +getDefer, +setSrc, +getSrc, +#if WEBKIT_CHECK_VERSION(2,2,2) +setCrossOrigin, +getCrossOrigin, +setNonce, +getNonce, #endif - HTMLScriptElement, HTMLScriptElementClass, castToHTMLScriptElement, - gTypeHTMLScriptElement, toHTMLScriptElement) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +HTMLScriptElement, +castToHTMLScriptElement, +gTypeHTMLScriptElement, +HTMLScriptElementClass, +toHTMLScriptElement, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM - -htmlScriptElementSetText :: - (HTMLScriptElementClass self) => self -> String -> IO () -htmlScriptElementSetText self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_script_element_set_text #} - (toHTMLScriptElement self) - valPtr +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -htmlScriptElementGetText :: - (HTMLScriptElementClass self) => self -> IO String -htmlScriptElementGetText self - = ({# call webkit_dom_html_script_element_get_text #} - (toHTMLScriptElement self)) - >>= - readUTFString +setText :: + (MonadIO m, HTMLScriptElementClass self, GlibString string) => + self -> (Maybe string) -> m () +setText self val + = liftIO + (maybeWith withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_script_element_set_text #} + (toHTMLScriptElement self) + valPtr) -htmlScriptElementSetHtmlFor :: - (HTMLScriptElementClass self) => self -> String -> IO () -htmlScriptElementSetHtmlFor self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_script_element_set_html_for #} - (toHTMLScriptElement self) - valPtr +getText :: + (MonadIO m, HTMLScriptElementClass self, GlibString string) => + self -> m (Maybe string) +getText self + = liftIO + (({# call webkit_dom_html_script_element_get_text #} + (toHTMLScriptElement self)) + >>= + maybePeek readUTFString) -htmlScriptElementGetHtmlFor :: - (HTMLScriptElementClass self) => self -> IO String -htmlScriptElementGetHtmlFor self - = ({# call webkit_dom_html_script_element_get_html_for #} - (toHTMLScriptElement self)) - >>= - readUTFString +setHtmlFor :: + (MonadIO m, HTMLScriptElementClass self, GlibString string) => + self -> string -> m () +setHtmlFor self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_script_element_set_html_for #} + (toHTMLScriptElement self) + valPtr) -htmlScriptElementSetEvent :: - (HTMLScriptElementClass self) => self -> String -> IO () -htmlScriptElementSetEvent self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_script_element_set_event #} - (toHTMLScriptElement self) - valPtr +getHtmlFor :: + (MonadIO m, HTMLScriptElementClass self, GlibString string) => + self -> m string +getHtmlFor self + = liftIO + (({# call webkit_dom_html_script_element_get_html_for #} + (toHTMLScriptElement self)) + >>= + readUTFString) -htmlScriptElementGetEvent :: - (HTMLScriptElementClass self) => self -> IO String -htmlScriptElementGetEvent self - = ({# call webkit_dom_html_script_element_get_event #} - (toHTMLScriptElement self)) - >>= - readUTFString +setEvent :: + (MonadIO m, HTMLScriptElementClass self, GlibString string) => + self -> string -> m () +setEvent self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_script_element_set_event #} + (toHTMLScriptElement self) + valPtr) -htmlScriptElementSetCharset :: - (HTMLScriptElementClass self) => self -> String -> IO () -htmlScriptElementSetCharset self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_script_element_set_charset #} - (toHTMLScriptElement self) - valPtr +getEvent :: + (MonadIO m, HTMLScriptElementClass self, GlibString string) => + self -> m string +getEvent self + = liftIO + (({# call webkit_dom_html_script_element_get_event #} + (toHTMLScriptElement self)) + >>= + readUTFString) -htmlScriptElementGetCharset :: - (HTMLScriptElementClass self) => self -> IO String -htmlScriptElementGetCharset self - = ({# call webkit_dom_html_script_element_get_charset #} - (toHTMLScriptElement self)) - >>= - readUTFString +setCharset :: + (MonadIO m, HTMLScriptElementClass self, GlibString string) => + self -> string -> m () +setCharset self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_script_element_set_charset #} + (toHTMLScriptElement self) + valPtr) -htmlScriptElementSetAsync :: - (HTMLScriptElementClass self) => self -> Bool -> IO () -htmlScriptElementSetAsync self val - = {# call webkit_dom_html_script_element_set_async #} - (toHTMLScriptElement self) - (fromBool val) +getCharset :: + (MonadIO m, HTMLScriptElementClass self, GlibString string) => + self -> m string +getCharset self + = liftIO + (({# call webkit_dom_html_script_element_get_charset #} + (toHTMLScriptElement self)) + >>= + readUTFString) -htmlScriptElementGetAsync :: - (HTMLScriptElementClass self) => self -> IO Bool -htmlScriptElementGetAsync self - = toBool <$> - ({# call webkit_dom_html_script_element_get_async #} - (toHTMLScriptElement self)) +setAsync :: + (MonadIO m, HTMLScriptElementClass self) => self -> Bool -> m () +setAsync self val + = liftIO + ({# call webkit_dom_html_script_element_set_async #} + (toHTMLScriptElement self) + (fromBool val)) -htmlScriptElementSetDefer :: - (HTMLScriptElementClass self) => self -> Bool -> IO () -htmlScriptElementSetDefer self val - = {# call webkit_dom_html_script_element_set_defer #} - (toHTMLScriptElement self) - (fromBool val) +getAsync :: + (MonadIO m, HTMLScriptElementClass self) => self -> m Bool +getAsync self + = liftIO + (toBool <$> + ({# call webkit_dom_html_script_element_get_async #} + (toHTMLScriptElement self))) -htmlScriptElementGetDefer :: - (HTMLScriptElementClass self) => self -> IO Bool -htmlScriptElementGetDefer self - = toBool <$> - ({# call webkit_dom_html_script_element_get_defer #} - (toHTMLScriptElement self)) +setDefer :: + (MonadIO m, HTMLScriptElementClass self) => self -> Bool -> m () +setDefer self val + = liftIO + ({# call webkit_dom_html_script_element_set_defer #} + (toHTMLScriptElement self) + (fromBool val)) -htmlScriptElementSetSrc :: - (HTMLScriptElementClass self) => self -> String -> IO () -htmlScriptElementSetSrc self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_script_element_set_src #} - (toHTMLScriptElement self) - valPtr +getDefer :: + (MonadIO m, HTMLScriptElementClass self) => self -> m Bool +getDefer self + = liftIO + (toBool <$> + ({# call webkit_dom_html_script_element_get_defer #} + (toHTMLScriptElement self))) -htmlScriptElementGetSrc :: - (HTMLScriptElementClass self) => self -> IO String -htmlScriptElementGetSrc self - = ({# call webkit_dom_html_script_element_get_src #} - (toHTMLScriptElement self)) - >>= - readUTFString +setSrc :: + (MonadIO m, HTMLScriptElementClass self, GlibString string) => + self -> string -> m () +setSrc self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_script_element_set_src #} + (toHTMLScriptElement self) + valPtr) -#if WEBKIT_CHECK_VERSION(1,10,0) -htmlScriptElementSetCrossOrigin :: - (HTMLScriptElementClass self) => self -> String -> IO () -htmlScriptElementSetCrossOrigin self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_script_element_set_cross_origin #} - (toHTMLScriptElement self) - valPtr +getSrc :: + (MonadIO m, HTMLScriptElementClass self, GlibString string) => + self -> m string +getSrc self + = liftIO + (({# call webkit_dom_html_script_element_get_src #} + (toHTMLScriptElement self)) + >>= + readUTFString) + +#if WEBKIT_CHECK_VERSION(2,2,2) +setCrossOrigin :: + (MonadIO m, HTMLScriptElementClass self, GlibString string) => + self -> string -> m () +setCrossOrigin self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_script_element_set_cross_origin #} + (toHTMLScriptElement self) + valPtr) -htmlScriptElementGetCrossOrigin :: - (HTMLScriptElementClass self) => self -> IO String -htmlScriptElementGetCrossOrigin self - = ({# call webkit_dom_html_script_element_get_cross_origin #} - (toHTMLScriptElement self)) - >>= - readUTFString +getCrossOrigin :: + (MonadIO m, HTMLScriptElementClass self, GlibString string) => + self -> m string +getCrossOrigin self + = liftIO + (({# call webkit_dom_html_script_element_get_cross_origin #} + (toHTMLScriptElement self)) + >>= + readUTFString) -htmlScriptElementSetNonce :: - (HTMLScriptElementClass self) => self -> String -> IO () -htmlScriptElementSetNonce self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_script_element_set_nonce #} - (toHTMLScriptElement self) - valPtr +setNonce :: + (MonadIO m, HTMLScriptElementClass self, GlibString string) => + self -> string -> m () +setNonce self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_script_element_set_nonce #} + (toHTMLScriptElement self) + valPtr) -htmlScriptElementGetNonce :: - (HTMLScriptElementClass self) => self -> IO String -htmlScriptElementGetNonce self - = ({# call webkit_dom_html_script_element_get_nonce #} - (toHTMLScriptElement self)) - >>= - readUTFString +getNonce :: + (MonadIO m, HTMLScriptElementClass self, GlibString string) => + self -> m string +getNonce self + = liftIO + (({# call webkit_dom_html_script_element_get_nonce #} + (toHTMLScriptElement self)) + >>= + readUTFString) #endif diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLSelectElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLSelectElement.chs --- a/Graphics/UI/Gtk/WebKit/DOM/HTMLSelectElement.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLSelectElement.chs @@ -1,272 +1,339 @@ -module Graphics.UI.Gtk.WebKit.DOM.HTMLSelectElement - (htmlSelectElementItem, htmlSelectElementNamedItem, - htmlSelectElementAdd, htmlSelectElementRemove, - htmlSelectElementCheckValidity, htmlSelectElementSetCustomValidity, - htmlSelectElementSetAutofocus, htmlSelectElementGetAutofocus, - htmlSelectElementSetDisabled, htmlSelectElementGetDisabled, - htmlSelectElementGetForm, htmlSelectElementSetMultiple, - htmlSelectElementGetMultiple, htmlSelectElementSetName, - htmlSelectElementGetName, htmlSelectElementSetRequired, - htmlSelectElementGetRequired, htmlSelectElementSetSize, - htmlSelectElementGetSize, htmlSelectElementGetOptions, - htmlSelectElementSetLength, htmlSelectElementGetLength, -#if WEBKIT_CHECK_VERSION(1,10,0) - htmlSelectElementGetSelectedOptions, +module Graphics.UI.Gtk.WebKit.DOM.HTMLSelectElement( +item, +namedItem, +addBefore, +remove, +checkValidity, +setCustomValidity, +setAutofocus, +getAutofocus, +setDisabled, +getDisabled, +getForm, +setMultiple, +getMultiple, +setName, +getName, +setRequired, +getRequired, +setSize, +getSize, +getOptions, +setLength, +getLength, +#if WEBKIT_CHECK_VERSION(2,2,2) +getSelectedOptions, #endif - htmlSelectElementSetSelectedIndex, - htmlSelectElementGetSelectedIndex, htmlSelectElementSetValue, - htmlSelectElementGetValue, htmlSelectElementGetWillValidate, - htmlSelectElementGetValidity, - htmlSelectElementGetValidationMessage, htmlSelectElementGetLabels, - HTMLSelectElement, HTMLSelectElementClass, castToHTMLSelectElement, - gTypeHTMLSelectElement, toHTMLSelectElement) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +setSelectedIndex, +getSelectedIndex, +setValue, +getValue, +getWillValidate, +getValidity, +getValidationMessage, +getLabels, +HTMLSelectElement, +castToHTMLSelectElement, +gTypeHTMLSelectElement, +HTMLSelectElementClass, +toHTMLSelectElement, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM - -htmlSelectElementItem :: - (HTMLSelectElementClass self) => self -> Word -> IO (Maybe Node) -htmlSelectElementItem self index - = maybeNull (makeNewGObject mkNode) - ({# call webkit_dom_html_select_element_item #} - (toHTMLSelectElement self) - (fromIntegral index)) +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -htmlSelectElementNamedItem :: - (HTMLSelectElementClass self) => self -> String -> IO (Maybe Node) -htmlSelectElementNamedItem self name - = maybeNull (makeNewGObject mkNode) - (withUTFString name $ - \ namePtr -> - {# call webkit_dom_html_select_element_named_item #} - (toHTMLSelectElement self) - namePtr) +item :: + (MonadIO m, HTMLSelectElementClass self) => + self -> Word -> m (Maybe Node) +item self index + = liftIO + (maybeNull (makeNewGObject mkNode) + ({# call webkit_dom_html_select_element_item #} + (toHTMLSelectElement self) + (fromIntegral index))) -htmlSelectElementAdd :: - (HTMLSelectElementClass self, HTMLElementClass element, - HTMLElementClass before) => - self -> Maybe element -> Maybe before -> IO () -htmlSelectElementAdd self element before - = propagateGError $ - \ errorPtr_ -> - {# call webkit_dom_html_select_element_add #} - (toHTMLSelectElement self) - (maybe (HTMLElement nullForeignPtr) toHTMLElement element) - (maybe (HTMLElement nullForeignPtr) toHTMLElement before) - errorPtr_ +namedItem :: + (MonadIO m, HTMLSelectElementClass self, GlibString string) => + self -> string -> m (Maybe Node) +namedItem self name + = liftIO + (maybeNull (makeNewGObject mkNode) + (withUTFString name $ + \ namePtr -> + {# call webkit_dom_html_select_element_named_item #} + (toHTMLSelectElement self) + namePtr)) -htmlSelectElementRemove :: - (HTMLSelectElementClass self) => self -> Int -> IO () -htmlSelectElementRemove self index - = {# call webkit_dom_html_select_element_remove #} - (toHTMLSelectElement self) - (fromIntegral index) +addBefore :: + (MonadIO m, HTMLSelectElementClass self, HTMLElementClass element, + HTMLElementClass before) => + self -> Maybe element -> Maybe before -> m () +addBefore self element before + = liftIO + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_html_select_element_add #} + (toHTMLSelectElement self) + (maybe (HTMLElement nullForeignPtr) toHTMLElement element) + (maybe (HTMLElement nullForeignPtr) toHTMLElement before) + errorPtr_) -htmlSelectElementCheckValidity :: - (HTMLSelectElementClass self) => self -> IO Bool -htmlSelectElementCheckValidity self - = toBool <$> - ({# call webkit_dom_html_select_element_check_validity #} - (toHTMLSelectElement self)) +remove :: + (MonadIO m, HTMLSelectElementClass self) => self -> Int -> m () +remove self index + = liftIO + ({# call webkit_dom_html_select_element_remove #} + (toHTMLSelectElement self) + (fromIntegral index)) -htmlSelectElementSetCustomValidity :: - (HTMLSelectElementClass self) => self -> String -> IO () -htmlSelectElementSetCustomValidity self error - = withUTFString error $ - \ errorPtr -> - {# call webkit_dom_html_select_element_set_custom_validity #} - (toHTMLSelectElement self) - errorPtr +checkValidity :: + (MonadIO m, HTMLSelectElementClass self) => self -> m Bool +checkValidity self + = liftIO + (toBool <$> + ({# call webkit_dom_html_select_element_check_validity #} + (toHTMLSelectElement self))) -htmlSelectElementSetAutofocus :: - (HTMLSelectElementClass self) => self -> Bool -> IO () -htmlSelectElementSetAutofocus self val - = {# call webkit_dom_html_select_element_set_autofocus #} - (toHTMLSelectElement self) - (fromBool val) +setCustomValidity :: + (MonadIO m, HTMLSelectElementClass self, GlibString string) => + self -> (Maybe string) -> m () +setCustomValidity self error + = liftIO + (maybeWith withUTFString error $ + \ errorPtr -> + {# call webkit_dom_html_select_element_set_custom_validity #} + (toHTMLSelectElement self) + errorPtr) -htmlSelectElementGetAutofocus :: - (HTMLSelectElementClass self) => self -> IO Bool -htmlSelectElementGetAutofocus self - = toBool <$> - ({# call webkit_dom_html_select_element_get_autofocus #} - (toHTMLSelectElement self)) +setAutofocus :: + (MonadIO m, HTMLSelectElementClass self) => self -> Bool -> m () +setAutofocus self val + = liftIO + ({# call webkit_dom_html_select_element_set_autofocus #} + (toHTMLSelectElement self) + (fromBool val)) -htmlSelectElementSetDisabled :: - (HTMLSelectElementClass self) => self -> Bool -> IO () -htmlSelectElementSetDisabled self val - = {# call webkit_dom_html_select_element_set_disabled #} - (toHTMLSelectElement self) - (fromBool val) +getAutofocus :: + (MonadIO m, HTMLSelectElementClass self) => self -> m Bool +getAutofocus self + = liftIO + (toBool <$> + ({# call webkit_dom_html_select_element_get_autofocus #} + (toHTMLSelectElement self))) -htmlSelectElementGetDisabled :: - (HTMLSelectElementClass self) => self -> IO Bool -htmlSelectElementGetDisabled self - = toBool <$> - ({# call webkit_dom_html_select_element_get_disabled #} - (toHTMLSelectElement self)) +setDisabled :: + (MonadIO m, HTMLSelectElementClass self) => self -> Bool -> m () +setDisabled self val + = liftIO + ({# call webkit_dom_html_select_element_set_disabled #} + (toHTMLSelectElement self) + (fromBool val)) -htmlSelectElementGetForm :: - (HTMLSelectElementClass self) => self -> IO (Maybe HTMLFormElement) -htmlSelectElementGetForm self - = maybeNull (makeNewGObject mkHTMLFormElement) - ({# call webkit_dom_html_select_element_get_form #} - (toHTMLSelectElement self)) +getDisabled :: + (MonadIO m, HTMLSelectElementClass self) => self -> m Bool +getDisabled self + = liftIO + (toBool <$> + ({# call webkit_dom_html_select_element_get_disabled #} + (toHTMLSelectElement self))) -htmlSelectElementSetMultiple :: - (HTMLSelectElementClass self) => self -> Bool -> IO () -htmlSelectElementSetMultiple self val - = {# call webkit_dom_html_select_element_set_multiple #} - (toHTMLSelectElement self) - (fromBool val) +getForm :: + (MonadIO m, HTMLSelectElementClass self) => + self -> m (Maybe HTMLFormElement) +getForm self + = liftIO + (maybeNull (makeNewGObject mkHTMLFormElement) + ({# call webkit_dom_html_select_element_get_form #} + (toHTMLSelectElement self))) -htmlSelectElementGetMultiple :: - (HTMLSelectElementClass self) => self -> IO Bool -htmlSelectElementGetMultiple self - = toBool <$> - ({# call webkit_dom_html_select_element_get_multiple #} - (toHTMLSelectElement self)) +setMultiple :: + (MonadIO m, HTMLSelectElementClass self) => self -> Bool -> m () +setMultiple self val + = liftIO + ({# call webkit_dom_html_select_element_set_multiple #} + (toHTMLSelectElement self) + (fromBool val)) -htmlSelectElementSetName :: - (HTMLSelectElementClass self) => self -> String -> IO () -htmlSelectElementSetName self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_select_element_set_name #} - (toHTMLSelectElement self) - valPtr +getMultiple :: + (MonadIO m, HTMLSelectElementClass self) => self -> m Bool +getMultiple self + = liftIO + (toBool <$> + ({# call webkit_dom_html_select_element_get_multiple #} + (toHTMLSelectElement self))) -htmlSelectElementGetName :: - (HTMLSelectElementClass self) => self -> IO String -htmlSelectElementGetName self - = ({# call webkit_dom_html_select_element_get_name #} - (toHTMLSelectElement self)) - >>= - readUTFString +setName :: + (MonadIO m, HTMLSelectElementClass self, GlibString string) => + self -> string -> m () +setName self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_select_element_set_name #} + (toHTMLSelectElement self) + valPtr) -htmlSelectElementSetRequired :: - (HTMLSelectElementClass self) => self -> Bool -> IO () -htmlSelectElementSetRequired self val - = {# call webkit_dom_html_select_element_set_required #} - (toHTMLSelectElement self) - (fromBool val) +getName :: + (MonadIO m, HTMLSelectElementClass self, GlibString string) => + self -> m string +getName self + = liftIO + (({# call webkit_dom_html_select_element_get_name #} + (toHTMLSelectElement self)) + >>= + readUTFString) -htmlSelectElementGetRequired :: - (HTMLSelectElementClass self) => self -> IO Bool -htmlSelectElementGetRequired self - = toBool <$> - ({# call webkit_dom_html_select_element_get_required #} - (toHTMLSelectElement self)) +setRequired :: + (MonadIO m, HTMLSelectElementClass self) => self -> Bool -> m () +setRequired self val + = liftIO + ({# call webkit_dom_html_select_element_set_required #} + (toHTMLSelectElement self) + (fromBool val)) -htmlSelectElementSetSize :: - (HTMLSelectElementClass self) => self -> Int -> IO () -htmlSelectElementSetSize self val - = {# call webkit_dom_html_select_element_set_size #} - (toHTMLSelectElement self) - (fromIntegral val) +getRequired :: + (MonadIO m, HTMLSelectElementClass self) => self -> m Bool +getRequired self + = liftIO + (toBool <$> + ({# call webkit_dom_html_select_element_get_required #} + (toHTMLSelectElement self))) -htmlSelectElementGetSize :: - (HTMLSelectElementClass self) => self -> IO Int -htmlSelectElementGetSize self - = fromIntegral <$> - ({# call webkit_dom_html_select_element_get_size #} - (toHTMLSelectElement self)) +setSize :: + (MonadIO m, HTMLSelectElementClass self) => self -> Int -> m () +setSize self val + = liftIO + ({# call webkit_dom_html_select_element_set_size #} + (toHTMLSelectElement self) + (fromIntegral val)) -htmlSelectElementGetOptions :: - (HTMLSelectElementClass self) => - self -> IO (Maybe HTMLOptionsCollection) -htmlSelectElementGetOptions self - = maybeNull (makeNewGObject mkHTMLOptionsCollection) - ({# call webkit_dom_html_select_element_get_options #} - (toHTMLSelectElement self)) +getSize :: + (MonadIO m, HTMLSelectElementClass self) => self -> m Int +getSize self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_select_element_get_size #} + (toHTMLSelectElement self))) -htmlSelectElementSetLength :: - (HTMLSelectElementClass self) => self -> Word -> IO () -htmlSelectElementSetLength self val - = propagateGError $ - \ errorPtr_ -> - {# call webkit_dom_html_select_element_set_length #} - (toHTMLSelectElement self) - (fromIntegral val) - errorPtr_ +getOptions :: + (MonadIO m, HTMLSelectElementClass self) => + self -> m (Maybe HTMLOptionsCollection) +getOptions self + = liftIO + (maybeNull (makeNewGObject mkHTMLOptionsCollection) + ({# call webkit_dom_html_select_element_get_options #} + (toHTMLSelectElement self))) -htmlSelectElementGetLength :: - (HTMLSelectElementClass self) => self -> IO Word -htmlSelectElementGetLength self - = fromIntegral <$> - ({# call webkit_dom_html_select_element_get_length #} - (toHTMLSelectElement self)) +setLength :: + (MonadIO m, HTMLSelectElementClass self) => self -> Word -> m () +setLength self val + = liftIO + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_html_select_element_set_length #} + (toHTMLSelectElement self) + (fromIntegral val) + errorPtr_) -#if WEBKIT_CHECK_VERSION(1,10,0) -htmlSelectElementGetSelectedOptions :: - (HTMLSelectElementClass self) => - self -> IO (Maybe HTMLCollection) -htmlSelectElementGetSelectedOptions self - = maybeNull (makeNewGObject mkHTMLCollection) - ({# call webkit_dom_html_select_element_get_selected_options #} - (toHTMLSelectElement self)) +getLength :: + (MonadIO m, HTMLSelectElementClass self) => self -> m Word +getLength self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_select_element_get_length #} + (toHTMLSelectElement self))) + +#if WEBKIT_CHECK_VERSION(2,2,2) +getSelectedOptions :: + (MonadIO m, HTMLSelectElementClass self) => + self -> m (Maybe HTMLCollection) +getSelectedOptions self + = liftIO + (maybeNull (makeNewGObject mkHTMLCollection) + ({# call webkit_dom_html_select_element_get_selected_options #} + (toHTMLSelectElement self))) #endif -htmlSelectElementSetSelectedIndex :: - (HTMLSelectElementClass self) => self -> Int -> IO () -htmlSelectElementSetSelectedIndex self val - = {# call webkit_dom_html_select_element_set_selected_index #} - (toHTMLSelectElement self) - (fromIntegral val) +setSelectedIndex :: + (MonadIO m, HTMLSelectElementClass self) => self -> Int -> m () +setSelectedIndex self val + = liftIO + ({# call webkit_dom_html_select_element_set_selected_index #} + (toHTMLSelectElement self) + (fromIntegral val)) -htmlSelectElementGetSelectedIndex :: - (HTMLSelectElementClass self) => self -> IO Int -htmlSelectElementGetSelectedIndex self - = fromIntegral <$> - ({# call webkit_dom_html_select_element_get_selected_index #} - (toHTMLSelectElement self)) +getSelectedIndex :: + (MonadIO m, HTMLSelectElementClass self) => self -> m Int +getSelectedIndex self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_select_element_get_selected_index #} + (toHTMLSelectElement self))) -htmlSelectElementSetValue :: - (HTMLSelectElementClass self) => self -> String -> IO () -htmlSelectElementSetValue self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_select_element_set_value #} - (toHTMLSelectElement self) - valPtr +setValue :: + (MonadIO m, HTMLSelectElementClass self, GlibString string) => + self -> (Maybe string) -> m () +setValue self val + = liftIO + (maybeWith withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_select_element_set_value #} + (toHTMLSelectElement self) + valPtr) -htmlSelectElementGetValue :: - (HTMLSelectElementClass self) => self -> IO String -htmlSelectElementGetValue self - = ({# call webkit_dom_html_select_element_get_value #} - (toHTMLSelectElement self)) - >>= - readUTFString +getValue :: + (MonadIO m, HTMLSelectElementClass self, GlibString string) => + self -> m (Maybe string) +getValue self + = liftIO + (({# call webkit_dom_html_select_element_get_value #} + (toHTMLSelectElement self)) + >>= + maybePeek readUTFString) -htmlSelectElementGetWillValidate :: - (HTMLSelectElementClass self) => self -> IO Bool -htmlSelectElementGetWillValidate self - = toBool <$> - ({# call webkit_dom_html_select_element_get_will_validate #} - (toHTMLSelectElement self)) +getWillValidate :: + (MonadIO m, HTMLSelectElementClass self) => self -> m Bool +getWillValidate self + = liftIO + (toBool <$> + ({# call webkit_dom_html_select_element_get_will_validate #} + (toHTMLSelectElement self))) -htmlSelectElementGetValidity :: - (HTMLSelectElementClass self) => self -> IO (Maybe ValidityState) -htmlSelectElementGetValidity self - = maybeNull (makeNewGObject mkValidityState) - ({# call webkit_dom_html_select_element_get_validity #} - (toHTMLSelectElement self)) +getValidity :: + (MonadIO m, HTMLSelectElementClass self) => + self -> m (Maybe ValidityState) +getValidity self + = liftIO + (maybeNull (makeNewGObject mkValidityState) + ({# call webkit_dom_html_select_element_get_validity #} + (toHTMLSelectElement self))) -htmlSelectElementGetValidationMessage :: - (HTMLSelectElementClass self) => self -> IO String -htmlSelectElementGetValidationMessage self - = ({# call webkit_dom_html_select_element_get_validation_message #} - (toHTMLSelectElement self)) - >>= - readUTFString +getValidationMessage :: + (MonadIO m, HTMLSelectElementClass self, GlibString string) => + self -> m string +getValidationMessage self + = liftIO + (({# call webkit_dom_html_select_element_get_validation_message #} + (toHTMLSelectElement self)) + >>= + readUTFString) -htmlSelectElementGetLabels :: - (HTMLSelectElementClass self) => self -> IO (Maybe NodeList) -htmlSelectElementGetLabels self - = maybeNull (makeNewGObject mkNodeList) - ({# call webkit_dom_html_select_element_get_labels #} - (toHTMLSelectElement self)) +getLabels :: + (MonadIO m, HTMLSelectElementClass self) => + self -> m (Maybe NodeList) +getLabels self + = liftIO + (maybeNull (makeNewGObject mkNodeList) + ({# call webkit_dom_html_select_element_get_labels #} + (toHTMLSelectElement self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLStyleElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLStyleElement.chs --- a/Graphics/UI/Gtk/WebKit/DOM/HTMLStyleElement.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLStyleElement.chs @@ -1,65 +1,72 @@ -module Graphics.UI.Gtk.WebKit.DOM.HTMLStyleElement - (htmlStyleElementSetDisabled, htmlStyleElementGetDisabled, - htmlStyleElementSetScoped, htmlStyleElementGetScoped, - htmlStyleElementSetMedia, htmlStyleElementGetMedia, - htmlStyleElementGetSheet, HTMLStyleElement, HTMLStyleElementClass, - castToHTMLStyleElement, gTypeHTMLStyleElement, toHTMLStyleElement) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.HTMLStyleElement( +setDisabled, +getDisabled, +setMedia, +getMedia, +getSheet, +HTMLStyleElement, +castToHTMLStyleElement, +gTypeHTMLStyleElement, +HTMLStyleElementClass, +toHTMLStyleElement, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM - -htmlStyleElementSetDisabled :: - (HTMLStyleElementClass self) => self -> Bool -> IO () -htmlStyleElementSetDisabled self val - = {# call webkit_dom_html_style_element_set_disabled #} - (toHTMLStyleElement self) - (fromBool val) - -htmlStyleElementGetDisabled :: - (HTMLStyleElementClass self) => self -> IO Bool -htmlStyleElementGetDisabled self - = toBool <$> - ({# call webkit_dom_html_style_element_get_disabled #} - (toHTMLStyleElement self)) +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -htmlStyleElementSetScoped :: - (HTMLStyleElementClass self) => self -> Bool -> IO () -htmlStyleElementSetScoped self val - = {# call webkit_dom_html_style_element_set_scoped #} - (toHTMLStyleElement self) - (fromBool val) +setDisabled :: + (MonadIO m, HTMLStyleElementClass self) => self -> Bool -> m () +setDisabled self val + = liftIO + ({# call webkit_dom_html_style_element_set_disabled #} + (toHTMLStyleElement self) + (fromBool val)) -htmlStyleElementGetScoped :: - (HTMLStyleElementClass self) => self -> IO Bool -htmlStyleElementGetScoped self - = toBool <$> - ({# call webkit_dom_html_style_element_get_scoped #} - (toHTMLStyleElement self)) +getDisabled :: + (MonadIO m, HTMLStyleElementClass self) => self -> m Bool +getDisabled self + = liftIO + (toBool <$> + ({# call webkit_dom_html_style_element_get_disabled #} + (toHTMLStyleElement self))) -htmlStyleElementSetMedia :: - (HTMLStyleElementClass self) => self -> String -> IO () -htmlStyleElementSetMedia self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_style_element_set_media #} - (toHTMLStyleElement self) - valPtr +setMedia :: + (MonadIO m, HTMLStyleElementClass self, GlibString string) => + self -> string -> m () +setMedia self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_style_element_set_media #} + (toHTMLStyleElement self) + valPtr) -htmlStyleElementGetMedia :: - (HTMLStyleElementClass self) => self -> IO String -htmlStyleElementGetMedia self - = ({# call webkit_dom_html_style_element_get_media #} - (toHTMLStyleElement self)) - >>= - readUTFString +getMedia :: + (MonadIO m, HTMLStyleElementClass self, GlibString string) => + self -> m string +getMedia self + = liftIO + (({# call webkit_dom_html_style_element_get_media #} + (toHTMLStyleElement self)) + >>= + readUTFString) -htmlStyleElementGetSheet :: - (HTMLStyleElementClass self) => self -> IO (Maybe StyleSheet) -htmlStyleElementGetSheet self - = maybeNull (makeNewGObject mkStyleSheet) - ({# call webkit_dom_html_style_element_get_sheet #} - (toHTMLStyleElement self)) +getSheet :: + (MonadIO m, HTMLStyleElementClass self) => + self -> m (Maybe StyleSheet) +getSheet self + = liftIO + (maybeNull (makeNewGObject mkStyleSheet) + ({# call webkit_dom_html_style_element_get_sheet #} + (toHTMLStyleElement self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLTableCaptionElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLTableCaptionElement.chs --- a/Graphics/UI/Gtk/WebKit/DOM/HTMLTableCaptionElement.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLTableCaptionElement.chs @@ -1,29 +1,46 @@ -module Graphics.UI.Gtk.WebKit.DOM.HTMLTableCaptionElement - (htmlTableCaptionElementSetAlign, htmlTableCaptionElementGetAlign, - HTMLTableCaptionElement, HTMLTableCaptionElementClass, - castToHTMLTableCaptionElement, gTypeHTMLTableCaptionElement, - toHTMLTableCaptionElement) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.HTMLTableCaptionElement( +setAlign, +getAlign, +HTMLTableCaptionElement, +castToHTMLTableCaptionElement, +gTypeHTMLTableCaptionElement, +HTMLTableCaptionElementClass, +toHTMLTableCaptionElement, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -htmlTableCaptionElementSetAlign :: - (HTMLTableCaptionElementClass self) => self -> String -> IO () -htmlTableCaptionElementSetAlign self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_table_caption_element_set_align #} - (toHTMLTableCaptionElement self) - valPtr +setAlign :: + (MonadIO m, HTMLTableCaptionElementClass self, + GlibString string) => + self -> string -> m () +setAlign self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_table_caption_element_set_align #} + (toHTMLTableCaptionElement self) + valPtr) -htmlTableCaptionElementGetAlign :: - (HTMLTableCaptionElementClass self) => self -> IO String -htmlTableCaptionElementGetAlign self - = ({# call webkit_dom_html_table_caption_element_get_align #} - (toHTMLTableCaptionElement self)) - >>= - readUTFString +getAlign :: + (MonadIO m, HTMLTableCaptionElementClass self, + GlibString string) => + self -> m string +getAlign self + = liftIO + (({# call webkit_dom_html_table_caption_element_get_align #} + (toHTMLTableCaptionElement self)) + >>= + readUTFString) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLTableCellElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLTableCellElement.chs --- a/Graphics/UI/Gtk/WebKit/DOM/HTMLTableCellElement.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLTableCellElement.chs @@ -1,261 +1,337 @@ -module Graphics.UI.Gtk.WebKit.DOM.HTMLTableCellElement - (htmlTableCellElementGetCellIndex, htmlTableCellElementSetAbbr, - htmlTableCellElementGetAbbr, htmlTableCellElementSetAlign, - htmlTableCellElementGetAlign, htmlTableCellElementSetAxis, - htmlTableCellElementGetAxis, htmlTableCellElementSetBgColor, - htmlTableCellElementGetBgColor, htmlTableCellElementSetCh, - htmlTableCellElementGetCh, htmlTableCellElementSetChOff, - htmlTableCellElementGetChOff, htmlTableCellElementSetColSpan, - htmlTableCellElementGetColSpan, htmlTableCellElementSetHeaders, - htmlTableCellElementGetHeaders, htmlTableCellElementSetHeight, - htmlTableCellElementGetHeight, htmlTableCellElementSetNoWrap, - htmlTableCellElementGetNoWrap, htmlTableCellElementSetRowSpan, - htmlTableCellElementGetRowSpan, htmlTableCellElementSetScope, - htmlTableCellElementGetScope, htmlTableCellElementSetVAlign, - htmlTableCellElementGetVAlign, htmlTableCellElementSetWidth, - htmlTableCellElementGetWidth, HTMLTableCellElement, - HTMLTableCellElementClass, castToHTMLTableCellElement, - gTypeHTMLTableCellElement, toHTMLTableCellElement) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.HTMLTableCellElement( +getCellIndex, +setAbbr, +getAbbr, +setAlign, +getAlign, +setAxis, +getAxis, +setBgColor, +getBgColor, +setCh, +getCh, +setChOff, +getChOff, +setColSpan, +getColSpan, +setHeaders, +getHeaders, +setHeight, +getHeight, +setNoWrap, +getNoWrap, +setRowSpan, +getRowSpan, +setScope, +getScope, +setVAlign, +getVAlign, +setWidth, +getWidth, +HTMLTableCellElement, +castToHTMLTableCellElement, +gTypeHTMLTableCellElement, +HTMLTableCellElementClass, +toHTMLTableCellElement, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -htmlTableCellElementGetCellIndex :: - (HTMLTableCellElementClass self) => self -> IO Int -htmlTableCellElementGetCellIndex self - = fromIntegral <$> - ({# call webkit_dom_html_table_cell_element_get_cell_index #} - (toHTMLTableCellElement self)) +getCellIndex :: + (MonadIO m, HTMLTableCellElementClass self) => self -> m Int +getCellIndex self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_table_cell_element_get_cell_index #} + (toHTMLTableCellElement self))) -htmlTableCellElementSetAbbr :: - (HTMLTableCellElementClass self) => self -> String -> IO () -htmlTableCellElementSetAbbr self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_table_cell_element_set_abbr #} - (toHTMLTableCellElement self) - valPtr +setAbbr :: + (MonadIO m, HTMLTableCellElementClass self, GlibString string) => + self -> string -> m () +setAbbr self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_table_cell_element_set_abbr #} + (toHTMLTableCellElement self) + valPtr) -htmlTableCellElementGetAbbr :: - (HTMLTableCellElementClass self) => self -> IO String -htmlTableCellElementGetAbbr self - = ({# call webkit_dom_html_table_cell_element_get_abbr #} - (toHTMLTableCellElement self)) - >>= - readUTFString +getAbbr :: + (MonadIO m, HTMLTableCellElementClass self, GlibString string) => + self -> m string +getAbbr self + = liftIO + (({# call webkit_dom_html_table_cell_element_get_abbr #} + (toHTMLTableCellElement self)) + >>= + readUTFString) -htmlTableCellElementSetAlign :: - (HTMLTableCellElementClass self) => self -> String -> IO () -htmlTableCellElementSetAlign self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_table_cell_element_set_align #} - (toHTMLTableCellElement self) - valPtr +setAlign :: + (MonadIO m, HTMLTableCellElementClass self, GlibString string) => + self -> string -> m () +setAlign self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_table_cell_element_set_align #} + (toHTMLTableCellElement self) + valPtr) -htmlTableCellElementGetAlign :: - (HTMLTableCellElementClass self) => self -> IO String -htmlTableCellElementGetAlign self - = ({# call webkit_dom_html_table_cell_element_get_align #} - (toHTMLTableCellElement self)) - >>= - readUTFString +getAlign :: + (MonadIO m, HTMLTableCellElementClass self, GlibString string) => + self -> m string +getAlign self + = liftIO + (({# call webkit_dom_html_table_cell_element_get_align #} + (toHTMLTableCellElement self)) + >>= + readUTFString) -htmlTableCellElementSetAxis :: - (HTMLTableCellElementClass self) => self -> String -> IO () -htmlTableCellElementSetAxis self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_table_cell_element_set_axis #} - (toHTMLTableCellElement self) - valPtr +setAxis :: + (MonadIO m, HTMLTableCellElementClass self, GlibString string) => + self -> string -> m () +setAxis self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_table_cell_element_set_axis #} + (toHTMLTableCellElement self) + valPtr) -htmlTableCellElementGetAxis :: - (HTMLTableCellElementClass self) => self -> IO String -htmlTableCellElementGetAxis self - = ({# call webkit_dom_html_table_cell_element_get_axis #} - (toHTMLTableCellElement self)) - >>= - readUTFString +getAxis :: + (MonadIO m, HTMLTableCellElementClass self, GlibString string) => + self -> m string +getAxis self + = liftIO + (({# call webkit_dom_html_table_cell_element_get_axis #} + (toHTMLTableCellElement self)) + >>= + readUTFString) -htmlTableCellElementSetBgColor :: - (HTMLTableCellElementClass self) => self -> String -> IO () -htmlTableCellElementSetBgColor self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_table_cell_element_set_bg_color #} - (toHTMLTableCellElement self) - valPtr +setBgColor :: + (MonadIO m, HTMLTableCellElementClass self, GlibString string) => + self -> string -> m () +setBgColor self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_table_cell_element_set_bg_color #} + (toHTMLTableCellElement self) + valPtr) -htmlTableCellElementGetBgColor :: - (HTMLTableCellElementClass self) => self -> IO String -htmlTableCellElementGetBgColor self - = ({# call webkit_dom_html_table_cell_element_get_bg_color #} - (toHTMLTableCellElement self)) - >>= - readUTFString +getBgColor :: + (MonadIO m, HTMLTableCellElementClass self, GlibString string) => + self -> m string +getBgColor self + = liftIO + (({# call webkit_dom_html_table_cell_element_get_bg_color #} + (toHTMLTableCellElement self)) + >>= + readUTFString) -htmlTableCellElementSetCh :: - (HTMLTableCellElementClass self) => self -> String -> IO () -htmlTableCellElementSetCh self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_table_cell_element_set_ch #} - (toHTMLTableCellElement self) - valPtr +setCh :: + (MonadIO m, HTMLTableCellElementClass self, GlibString string) => + self -> string -> m () +setCh self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_table_cell_element_set_ch #} + (toHTMLTableCellElement self) + valPtr) -htmlTableCellElementGetCh :: - (HTMLTableCellElementClass self) => self -> IO String -htmlTableCellElementGetCh self - = ({# call webkit_dom_html_table_cell_element_get_ch #} - (toHTMLTableCellElement self)) - >>= - readUTFString +getCh :: + (MonadIO m, HTMLTableCellElementClass self, GlibString string) => + self -> m string +getCh self + = liftIO + (({# call webkit_dom_html_table_cell_element_get_ch #} + (toHTMLTableCellElement self)) + >>= + readUTFString) -htmlTableCellElementSetChOff :: - (HTMLTableCellElementClass self) => self -> String -> IO () -htmlTableCellElementSetChOff self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_table_cell_element_set_ch_off #} - (toHTMLTableCellElement self) - valPtr +setChOff :: + (MonadIO m, HTMLTableCellElementClass self, GlibString string) => + self -> string -> m () +setChOff self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_table_cell_element_set_ch_off #} + (toHTMLTableCellElement self) + valPtr) -htmlTableCellElementGetChOff :: - (HTMLTableCellElementClass self) => self -> IO String -htmlTableCellElementGetChOff self - = ({# call webkit_dom_html_table_cell_element_get_ch_off #} - (toHTMLTableCellElement self)) - >>= - readUTFString +getChOff :: + (MonadIO m, HTMLTableCellElementClass self, GlibString string) => + self -> m string +getChOff self + = liftIO + (({# call webkit_dom_html_table_cell_element_get_ch_off #} + (toHTMLTableCellElement self)) + >>= + readUTFString) -htmlTableCellElementSetColSpan :: - (HTMLTableCellElementClass self) => self -> Int -> IO () -htmlTableCellElementSetColSpan self val - = {# call webkit_dom_html_table_cell_element_set_col_span #} - (toHTMLTableCellElement self) - (fromIntegral val) +setColSpan :: + (MonadIO m, HTMLTableCellElementClass self) => self -> Int -> m () +setColSpan self val + = liftIO + ({# call webkit_dom_html_table_cell_element_set_col_span #} + (toHTMLTableCellElement self) + (fromIntegral val)) -htmlTableCellElementGetColSpan :: - (HTMLTableCellElementClass self) => self -> IO Int -htmlTableCellElementGetColSpan self - = fromIntegral <$> - ({# call webkit_dom_html_table_cell_element_get_col_span #} - (toHTMLTableCellElement self)) +getColSpan :: + (MonadIO m, HTMLTableCellElementClass self) => self -> m Int +getColSpan self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_table_cell_element_get_col_span #} + (toHTMLTableCellElement self))) -htmlTableCellElementSetHeaders :: - (HTMLTableCellElementClass self) => self -> String -> IO () -htmlTableCellElementSetHeaders self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_table_cell_element_set_headers #} - (toHTMLTableCellElement self) - valPtr +setHeaders :: + (MonadIO m, HTMLTableCellElementClass self, GlibString string) => + self -> string -> m () +setHeaders self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_table_cell_element_set_headers #} + (toHTMLTableCellElement self) + valPtr) -htmlTableCellElementGetHeaders :: - (HTMLTableCellElementClass self) => self -> IO String -htmlTableCellElementGetHeaders self - = ({# call webkit_dom_html_table_cell_element_get_headers #} - (toHTMLTableCellElement self)) - >>= - readUTFString +getHeaders :: + (MonadIO m, HTMLTableCellElementClass self, GlibString string) => + self -> m string +getHeaders self + = liftIO + (({# call webkit_dom_html_table_cell_element_get_headers #} + (toHTMLTableCellElement self)) + >>= + readUTFString) -htmlTableCellElementSetHeight :: - (HTMLTableCellElementClass self) => self -> String -> IO () -htmlTableCellElementSetHeight self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_table_cell_element_set_height #} - (toHTMLTableCellElement self) - valPtr +setHeight :: + (MonadIO m, HTMLTableCellElementClass self, GlibString string) => + self -> string -> m () +setHeight self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_table_cell_element_set_height #} + (toHTMLTableCellElement self) + valPtr) -htmlTableCellElementGetHeight :: - (HTMLTableCellElementClass self) => self -> IO String -htmlTableCellElementGetHeight self - = ({# call webkit_dom_html_table_cell_element_get_height #} - (toHTMLTableCellElement self)) - >>= - readUTFString +getHeight :: + (MonadIO m, HTMLTableCellElementClass self, GlibString string) => + self -> m string +getHeight self + = liftIO + (({# call webkit_dom_html_table_cell_element_get_height #} + (toHTMLTableCellElement self)) + >>= + readUTFString) -htmlTableCellElementSetNoWrap :: - (HTMLTableCellElementClass self) => self -> Bool -> IO () -htmlTableCellElementSetNoWrap self val - = {# call webkit_dom_html_table_cell_element_set_no_wrap #} - (toHTMLTableCellElement self) - (fromBool val) +setNoWrap :: + (MonadIO m, HTMLTableCellElementClass self) => self -> Bool -> m () +setNoWrap self val + = liftIO + ({# call webkit_dom_html_table_cell_element_set_no_wrap #} + (toHTMLTableCellElement self) + (fromBool val)) -htmlTableCellElementGetNoWrap :: - (HTMLTableCellElementClass self) => self -> IO Bool -htmlTableCellElementGetNoWrap self - = toBool <$> - ({# call webkit_dom_html_table_cell_element_get_no_wrap #} - (toHTMLTableCellElement self)) +getNoWrap :: + (MonadIO m, HTMLTableCellElementClass self) => self -> m Bool +getNoWrap self + = liftIO + (toBool <$> + ({# call webkit_dom_html_table_cell_element_get_no_wrap #} + (toHTMLTableCellElement self))) -htmlTableCellElementSetRowSpan :: - (HTMLTableCellElementClass self) => self -> Int -> IO () -htmlTableCellElementSetRowSpan self val - = {# call webkit_dom_html_table_cell_element_set_row_span #} - (toHTMLTableCellElement self) - (fromIntegral val) +setRowSpan :: + (MonadIO m, HTMLTableCellElementClass self) => self -> Int -> m () +setRowSpan self val + = liftIO + ({# call webkit_dom_html_table_cell_element_set_row_span #} + (toHTMLTableCellElement self) + (fromIntegral val)) -htmlTableCellElementGetRowSpan :: - (HTMLTableCellElementClass self) => self -> IO Int -htmlTableCellElementGetRowSpan self - = fromIntegral <$> - ({# call webkit_dom_html_table_cell_element_get_row_span #} - (toHTMLTableCellElement self)) +getRowSpan :: + (MonadIO m, HTMLTableCellElementClass self) => self -> m Int +getRowSpan self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_table_cell_element_get_row_span #} + (toHTMLTableCellElement self))) -htmlTableCellElementSetScope :: - (HTMLTableCellElementClass self) => self -> String -> IO () -htmlTableCellElementSetScope self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_table_cell_element_set_scope #} - (toHTMLTableCellElement self) - valPtr +setScope :: + (MonadIO m, HTMLTableCellElementClass self, GlibString string) => + self -> string -> m () +setScope self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_table_cell_element_set_scope #} + (toHTMLTableCellElement self) + valPtr) -htmlTableCellElementGetScope :: - (HTMLTableCellElementClass self) => self -> IO String -htmlTableCellElementGetScope self - = ({# call webkit_dom_html_table_cell_element_get_scope #} - (toHTMLTableCellElement self)) - >>= - readUTFString +getScope :: + (MonadIO m, HTMLTableCellElementClass self, GlibString string) => + self -> m string +getScope self + = liftIO + (({# call webkit_dom_html_table_cell_element_get_scope #} + (toHTMLTableCellElement self)) + >>= + readUTFString) -htmlTableCellElementSetVAlign :: - (HTMLTableCellElementClass self) => self -> String -> IO () -htmlTableCellElementSetVAlign self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_table_cell_element_set_v_align #} - (toHTMLTableCellElement self) - valPtr +setVAlign :: + (MonadIO m, HTMLTableCellElementClass self, GlibString string) => + self -> string -> m () +setVAlign self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_table_cell_element_set_v_align #} + (toHTMLTableCellElement self) + valPtr) -htmlTableCellElementGetVAlign :: - (HTMLTableCellElementClass self) => self -> IO String -htmlTableCellElementGetVAlign self - = ({# call webkit_dom_html_table_cell_element_get_v_align #} - (toHTMLTableCellElement self)) - >>= - readUTFString +getVAlign :: + (MonadIO m, HTMLTableCellElementClass self, GlibString string) => + self -> m string +getVAlign self + = liftIO + (({# call webkit_dom_html_table_cell_element_get_v_align #} + (toHTMLTableCellElement self)) + >>= + readUTFString) -htmlTableCellElementSetWidth :: - (HTMLTableCellElementClass self) => self -> String -> IO () -htmlTableCellElementSetWidth self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_table_cell_element_set_width #} - (toHTMLTableCellElement self) - valPtr +setWidth :: + (MonadIO m, HTMLTableCellElementClass self, GlibString string) => + self -> string -> m () +setWidth self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_table_cell_element_set_width #} + (toHTMLTableCellElement self) + valPtr) -htmlTableCellElementGetWidth :: - (HTMLTableCellElementClass self) => self -> IO String -htmlTableCellElementGetWidth self - = ({# call webkit_dom_html_table_cell_element_get_width #} - (toHTMLTableCellElement self)) - >>= - readUTFString +getWidth :: + (MonadIO m, HTMLTableCellElementClass self, GlibString string) => + self -> m string +getWidth self + = liftIO + (({# call webkit_dom_html_table_cell_element_get_width #} + (toHTMLTableCellElement self)) + >>= + readUTFString) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLTableColElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLTableColElement.chs --- a/Graphics/UI/Gtk/WebKit/DOM/HTMLTableColElement.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLTableColElement.chs @@ -1,116 +1,154 @@ -module Graphics.UI.Gtk.WebKit.DOM.HTMLTableColElement - (htmlTableColElementSetAlign, htmlTableColElementGetAlign, - htmlTableColElementSetCh, htmlTableColElementGetCh, - htmlTableColElementSetChOff, htmlTableColElementGetChOff, - htmlTableColElementSetSpan, htmlTableColElementGetSpan, - htmlTableColElementSetVAlign, htmlTableColElementGetVAlign, - htmlTableColElementSetWidth, htmlTableColElementGetWidth, - HTMLTableColElement, HTMLTableColElementClass, - castToHTMLTableColElement, gTypeHTMLTableColElement, - toHTMLTableColElement) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.HTMLTableColElement( +setAlign, +getAlign, +setCh, +getCh, +setChOff, +getChOff, +setSpan, +getSpan, +setVAlign, +getVAlign, +setWidth, +getWidth, +HTMLTableColElement, +castToHTMLTableColElement, +gTypeHTMLTableColElement, +HTMLTableColElementClass, +toHTMLTableColElement, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -htmlTableColElementSetAlign :: - (HTMLTableColElementClass self) => self -> String -> IO () -htmlTableColElementSetAlign self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_table_col_element_set_align #} - (toHTMLTableColElement self) - valPtr +setAlign :: + (MonadIO m, HTMLTableColElementClass self, GlibString string) => + self -> string -> m () +setAlign self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_table_col_element_set_align #} + (toHTMLTableColElement self) + valPtr) -htmlTableColElementGetAlign :: - (HTMLTableColElementClass self) => self -> IO String -htmlTableColElementGetAlign self - = ({# call webkit_dom_html_table_col_element_get_align #} - (toHTMLTableColElement self)) - >>= - readUTFString +getAlign :: + (MonadIO m, HTMLTableColElementClass self, GlibString string) => + self -> m string +getAlign self + = liftIO + (({# call webkit_dom_html_table_col_element_get_align #} + (toHTMLTableColElement self)) + >>= + readUTFString) -htmlTableColElementSetCh :: - (HTMLTableColElementClass self) => self -> String -> IO () -htmlTableColElementSetCh self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_table_col_element_set_ch #} - (toHTMLTableColElement self) - valPtr +setCh :: + (MonadIO m, HTMLTableColElementClass self, GlibString string) => + self -> string -> m () +setCh self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_table_col_element_set_ch #} + (toHTMLTableColElement self) + valPtr) -htmlTableColElementGetCh :: - (HTMLTableColElementClass self) => self -> IO String -htmlTableColElementGetCh self - = ({# call webkit_dom_html_table_col_element_get_ch #} - (toHTMLTableColElement self)) - >>= - readUTFString +getCh :: + (MonadIO m, HTMLTableColElementClass self, GlibString string) => + self -> m string +getCh self + = liftIO + (({# call webkit_dom_html_table_col_element_get_ch #} + (toHTMLTableColElement self)) + >>= + readUTFString) -htmlTableColElementSetChOff :: - (HTMLTableColElementClass self) => self -> String -> IO () -htmlTableColElementSetChOff self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_table_col_element_set_ch_off #} - (toHTMLTableColElement self) - valPtr +setChOff :: + (MonadIO m, HTMLTableColElementClass self, GlibString string) => + self -> string -> m () +setChOff self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_table_col_element_set_ch_off #} + (toHTMLTableColElement self) + valPtr) -htmlTableColElementGetChOff :: - (HTMLTableColElementClass self) => self -> IO String -htmlTableColElementGetChOff self - = ({# call webkit_dom_html_table_col_element_get_ch_off #} - (toHTMLTableColElement self)) - >>= - readUTFString +getChOff :: + (MonadIO m, HTMLTableColElementClass self, GlibString string) => + self -> m string +getChOff self + = liftIO + (({# call webkit_dom_html_table_col_element_get_ch_off #} + (toHTMLTableColElement self)) + >>= + readUTFString) -htmlTableColElementSetSpan :: - (HTMLTableColElementClass self) => self -> Int -> IO () -htmlTableColElementSetSpan self val - = {# call webkit_dom_html_table_col_element_set_span #} - (toHTMLTableColElement self) - (fromIntegral val) +setSpan :: + (MonadIO m, HTMLTableColElementClass self) => self -> Int -> m () +setSpan self val + = liftIO + ({# call webkit_dom_html_table_col_element_set_span #} + (toHTMLTableColElement self) + (fromIntegral val)) -htmlTableColElementGetSpan :: - (HTMLTableColElementClass self) => self -> IO Int -htmlTableColElementGetSpan self - = fromIntegral <$> - ({# call webkit_dom_html_table_col_element_get_span #} - (toHTMLTableColElement self)) +getSpan :: + (MonadIO m, HTMLTableColElementClass self) => self -> m Int +getSpan self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_table_col_element_get_span #} + (toHTMLTableColElement self))) -htmlTableColElementSetVAlign :: - (HTMLTableColElementClass self) => self -> String -> IO () -htmlTableColElementSetVAlign self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_table_col_element_set_v_align #} - (toHTMLTableColElement self) - valPtr +setVAlign :: + (MonadIO m, HTMLTableColElementClass self, GlibString string) => + self -> string -> m () +setVAlign self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_table_col_element_set_v_align #} + (toHTMLTableColElement self) + valPtr) -htmlTableColElementGetVAlign :: - (HTMLTableColElementClass self) => self -> IO String -htmlTableColElementGetVAlign self - = ({# call webkit_dom_html_table_col_element_get_v_align #} - (toHTMLTableColElement self)) - >>= - readUTFString +getVAlign :: + (MonadIO m, HTMLTableColElementClass self, GlibString string) => + self -> m string +getVAlign self + = liftIO + (({# call webkit_dom_html_table_col_element_get_v_align #} + (toHTMLTableColElement self)) + >>= + readUTFString) -htmlTableColElementSetWidth :: - (HTMLTableColElementClass self) => self -> String -> IO () -htmlTableColElementSetWidth self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_table_col_element_set_width #} - (toHTMLTableColElement self) - valPtr +setWidth :: + (MonadIO m, HTMLTableColElementClass self, GlibString string) => + self -> string -> m () +setWidth self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_table_col_element_set_width #} + (toHTMLTableColElement self) + valPtr) -htmlTableColElementGetWidth :: - (HTMLTableColElementClass self) => self -> IO String -htmlTableColElementGetWidth self - = ({# call webkit_dom_html_table_col_element_get_width #} - (toHTMLTableColElement self)) - >>= - readUTFString +getWidth :: + (MonadIO m, HTMLTableColElementClass self, GlibString string) => + self -> m string +getWidth self + = liftIO + (({# call webkit_dom_html_table_col_element_get_width #} + (toHTMLTableColElement self)) + >>= + readUTFString) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLTableElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLTableElement.chs --- a/Graphics/UI/Gtk/WebKit/DOM/HTMLTableElement.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLTableElement.chs @@ -1,330 +1,420 @@ -module Graphics.UI.Gtk.WebKit.DOM.HTMLTableElement - (htmlTableElementCreateTHead, htmlTableElementDeleteTHead, - htmlTableElementCreateTFoot, htmlTableElementDeleteTFoot, -#if WEBKIT_CHECK_VERSION(1,10,0) - htmlTableElementCreateTBody, +module Graphics.UI.Gtk.WebKit.DOM.HTMLTableElement( +createTHead, +deleteTHead, +createTFoot, +deleteTFoot, +#if WEBKIT_CHECK_VERSION(2,2,2) +createTBody, #endif - htmlTableElementCreateCaption, - htmlTableElementDeleteCaption, htmlTableElementInsertRow, - htmlTableElementDeleteRow, htmlTableElementSetCaption, - htmlTableElementGetCaption, htmlTableElementSetTHead, - htmlTableElementGetTHead, htmlTableElementSetTFoot, - htmlTableElementGetTFoot, htmlTableElementGetRows, - htmlTableElementGetTBodies, htmlTableElementSetAlign, - htmlTableElementGetAlign, htmlTableElementSetBgColor, - htmlTableElementGetBgColor, htmlTableElementSetBorder, - htmlTableElementGetBorder, htmlTableElementSetCellPadding, - htmlTableElementGetCellPadding, htmlTableElementSetCellSpacing, - htmlTableElementGetCellSpacing, htmlTableElementSetFrame, - htmlTableElementGetFrame, htmlTableElementSetRules, - htmlTableElementGetRules, htmlTableElementSetSummary, - htmlTableElementGetSummary, htmlTableElementSetWidth, - htmlTableElementGetWidth, HTMLTableElement, HTMLTableElementClass, - castToHTMLTableElement, gTypeHTMLTableElement, toHTMLTableElement) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +createCaption, +deleteCaption, +insertRow, +deleteRow, +setCaption, +getCaption, +setTHead, +getTHead, +setTFoot, +getTFoot, +getRows, +getTBodies, +setAlign, +getAlign, +setBgColor, +getBgColor, +setBorder, +getBorder, +setCellPadding, +getCellPadding, +setCellSpacing, +getCellSpacing, +setFrame, +getFrame, +setRules, +getRules, +setSummary, +getSummary, +setWidth, +getWidth, +HTMLTableElement, +castToHTMLTableElement, +gTypeHTMLTableElement, +HTMLTableElementClass, +toHTMLTableElement, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM - -htmlTableElementCreateTHead :: - (HTMLTableElementClass self) => self -> IO (Maybe HTMLElement) -htmlTableElementCreateTHead self - = maybeNull (makeNewGObject mkHTMLElement) - ({# call webkit_dom_html_table_element_create_t_head #} - (toHTMLTableElement self)) +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -htmlTableElementDeleteTHead :: - (HTMLTableElementClass self) => self -> IO () -htmlTableElementDeleteTHead self - = {# call webkit_dom_html_table_element_delete_t_head #} - (toHTMLTableElement self) +createTHead :: + (MonadIO m, HTMLTableElementClass self) => + self -> m (Maybe HTMLElement) +createTHead self + = liftIO + (maybeNull (makeNewGObject mkHTMLElement) + ({# call webkit_dom_html_table_element_create_t_head #} + (toHTMLTableElement self))) -htmlTableElementCreateTFoot :: - (HTMLTableElementClass self) => self -> IO (Maybe HTMLElement) -htmlTableElementCreateTFoot self - = maybeNull (makeNewGObject mkHTMLElement) - ({# call webkit_dom_html_table_element_create_t_foot #} +deleteTHead :: + (MonadIO m, HTMLTableElementClass self) => self -> m () +deleteTHead self + = liftIO + ({# call webkit_dom_html_table_element_delete_t_head #} (toHTMLTableElement self)) -htmlTableElementDeleteTFoot :: - (HTMLTableElementClass self) => self -> IO () -htmlTableElementDeleteTFoot self - = {# call webkit_dom_html_table_element_delete_t_foot #} - (toHTMLTableElement self) +createTFoot :: + (MonadIO m, HTMLTableElementClass self) => + self -> m (Maybe HTMLElement) +createTFoot self + = liftIO + (maybeNull (makeNewGObject mkHTMLElement) + ({# call webkit_dom_html_table_element_create_t_foot #} + (toHTMLTableElement self))) -#if WEBKIT_CHECK_VERSION(1,10,0) -htmlTableElementCreateTBody :: - (HTMLTableElementClass self) => self -> IO (Maybe HTMLElement) -htmlTableElementCreateTBody self - = maybeNull (makeNewGObject mkHTMLElement) - ({# call webkit_dom_html_table_element_create_t_body #} +deleteTFoot :: + (MonadIO m, HTMLTableElementClass self) => self -> m () +deleteTFoot self + = liftIO + ({# call webkit_dom_html_table_element_delete_t_foot #} (toHTMLTableElement self)) + +#if WEBKIT_CHECK_VERSION(2,2,2) +createTBody :: + (MonadIO m, HTMLTableElementClass self) => + self -> m (Maybe HTMLElement) +createTBody self + = liftIO + (maybeNull (makeNewGObject mkHTMLElement) + ({# call webkit_dom_html_table_element_create_t_body #} + (toHTMLTableElement self))) #endif -htmlTableElementCreateCaption :: - (HTMLTableElementClass self) => self -> IO (Maybe HTMLElement) -htmlTableElementCreateCaption self - = maybeNull (makeNewGObject mkHTMLElement) - ({# call webkit_dom_html_table_element_create_caption #} +createCaption :: + (MonadIO m, HTMLTableElementClass self) => + self -> m (Maybe HTMLElement) +createCaption self + = liftIO + (maybeNull (makeNewGObject mkHTMLElement) + ({# call webkit_dom_html_table_element_create_caption #} + (toHTMLTableElement self))) + +deleteCaption :: + (MonadIO m, HTMLTableElementClass self) => self -> m () +deleteCaption self + = liftIO + ({# call webkit_dom_html_table_element_delete_caption #} (toHTMLTableElement self)) -htmlTableElementDeleteCaption :: - (HTMLTableElementClass self) => self -> IO () -htmlTableElementDeleteCaption self - = {# call webkit_dom_html_table_element_delete_caption #} - (toHTMLTableElement self) +insertRow :: + (MonadIO m, HTMLTableElementClass self) => + self -> Int -> m (Maybe HTMLElement) +insertRow self index + = liftIO + (maybeNull (makeNewGObject mkHTMLElement) + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_html_table_element_insert_row #} + (toHTMLTableElement self) + (fromIntegral index) + errorPtr_)) -htmlTableElementInsertRow :: - (HTMLTableElementClass self) => - self -> Int -> IO (Maybe HTMLElement) -htmlTableElementInsertRow self index - = maybeNull (makeNewGObject mkHTMLElement) +deleteRow :: + (MonadIO m, HTMLTableElementClass self) => self -> Int -> m () +deleteRow self index + = liftIO (propagateGError $ \ errorPtr_ -> - {# call webkit_dom_html_table_element_insert_row #} + {# call webkit_dom_html_table_element_delete_row #} (toHTMLTableElement self) (fromIntegral index) errorPtr_) -htmlTableElementDeleteRow :: - (HTMLTableElementClass self) => self -> Int -> IO () -htmlTableElementDeleteRow self index - = propagateGError $ - \ errorPtr_ -> - {# call webkit_dom_html_table_element_delete_row #} - (toHTMLTableElement self) - (fromIntegral index) - errorPtr_ - -htmlTableElementSetCaption :: - (HTMLTableCaptionElementClass val, HTMLTableElementClass self) => - self -> Maybe val -> IO () -htmlTableElementSetCaption self val - = propagateGError $ - \ errorPtr_ -> - {# call webkit_dom_html_table_element_set_caption #} - (toHTMLTableElement self) - (maybe (HTMLTableCaptionElement nullForeignPtr) - toHTMLTableCaptionElement - val) - errorPtr_ +setCaption :: + (MonadIO m, HTMLTableCaptionElementClass val, + HTMLTableElementClass self) => + self -> Maybe val -> m () +setCaption self val + = liftIO + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_html_table_element_set_caption #} + (toHTMLTableElement self) + (maybe (HTMLTableCaptionElement nullForeignPtr) + toHTMLTableCaptionElement + val) + errorPtr_) -htmlTableElementGetCaption :: - (HTMLTableElementClass self) => - self -> IO (Maybe HTMLTableCaptionElement) -htmlTableElementGetCaption self - = maybeNull (makeNewGObject mkHTMLTableCaptionElement) - ({# call webkit_dom_html_table_element_get_caption #} - (toHTMLTableElement self)) +getCaption :: + (MonadIO m, HTMLTableElementClass self) => + self -> m (Maybe HTMLTableCaptionElement) +getCaption self + = liftIO + (maybeNull (makeNewGObject mkHTMLTableCaptionElement) + ({# call webkit_dom_html_table_element_get_caption #} + (toHTMLTableElement self))) -htmlTableElementSetTHead :: - (HTMLTableSectionElementClass val, HTMLTableElementClass self) => - self -> Maybe val -> IO () -htmlTableElementSetTHead self val - = propagateGError $ - \ errorPtr_ -> - {# call webkit_dom_html_table_element_set_t_head #} - (toHTMLTableElement self) - (maybe (HTMLTableSectionElement nullForeignPtr) - toHTMLTableSectionElement - val) - errorPtr_ +setTHead :: + (MonadIO m, HTMLTableSectionElementClass val, + HTMLTableElementClass self) => + self -> Maybe val -> m () +setTHead self val + = liftIO + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_html_table_element_set_t_head #} + (toHTMLTableElement self) + (maybe (HTMLTableSectionElement nullForeignPtr) + toHTMLTableSectionElement + val) + errorPtr_) -htmlTableElementGetTHead :: - (HTMLTableElementClass self) => - self -> IO (Maybe HTMLTableSectionElement) -htmlTableElementGetTHead self - = maybeNull (makeNewGObject mkHTMLTableSectionElement) - ({# call webkit_dom_html_table_element_get_t_head #} - (toHTMLTableElement self)) +getTHead :: + (MonadIO m, HTMLTableElementClass self) => + self -> m (Maybe HTMLTableSectionElement) +getTHead self + = liftIO + (maybeNull (makeNewGObject mkHTMLTableSectionElement) + ({# call webkit_dom_html_table_element_get_t_head #} + (toHTMLTableElement self))) -htmlTableElementSetTFoot :: - (HTMLTableSectionElementClass val, HTMLTableElementClass self) => - self -> Maybe val -> IO () -htmlTableElementSetTFoot self val - = propagateGError $ - \ errorPtr_ -> - {# call webkit_dom_html_table_element_set_t_foot #} - (toHTMLTableElement self) - (maybe (HTMLTableSectionElement nullForeignPtr) - toHTMLTableSectionElement - val) - errorPtr_ +setTFoot :: + (MonadIO m, HTMLTableSectionElementClass val, + HTMLTableElementClass self) => + self -> Maybe val -> m () +setTFoot self val + = liftIO + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_html_table_element_set_t_foot #} + (toHTMLTableElement self) + (maybe (HTMLTableSectionElement nullForeignPtr) + toHTMLTableSectionElement + val) + errorPtr_) -htmlTableElementGetTFoot :: - (HTMLTableElementClass self) => - self -> IO (Maybe HTMLTableSectionElement) -htmlTableElementGetTFoot self - = maybeNull (makeNewGObject mkHTMLTableSectionElement) - ({# call webkit_dom_html_table_element_get_t_foot #} - (toHTMLTableElement self)) +getTFoot :: + (MonadIO m, HTMLTableElementClass self) => + self -> m (Maybe HTMLTableSectionElement) +getTFoot self + = liftIO + (maybeNull (makeNewGObject mkHTMLTableSectionElement) + ({# call webkit_dom_html_table_element_get_t_foot #} + (toHTMLTableElement self))) -htmlTableElementGetRows :: - (HTMLTableElementClass self) => self -> IO (Maybe HTMLCollection) -htmlTableElementGetRows self - = maybeNull (makeNewGObject mkHTMLCollection) - ({# call webkit_dom_html_table_element_get_rows #} - (toHTMLTableElement self)) +getRows :: + (MonadIO m, HTMLTableElementClass self) => + self -> m (Maybe HTMLCollection) +getRows self + = liftIO + (maybeNull (makeNewGObject mkHTMLCollection) + ({# call webkit_dom_html_table_element_get_rows #} + (toHTMLTableElement self))) -htmlTableElementGetTBodies :: - (HTMLTableElementClass self) => self -> IO (Maybe HTMLCollection) -htmlTableElementGetTBodies self - = maybeNull (makeNewGObject mkHTMLCollection) - ({# call webkit_dom_html_table_element_get_t_bodies #} - (toHTMLTableElement self)) +getTBodies :: + (MonadIO m, HTMLTableElementClass self) => + self -> m (Maybe HTMLCollection) +getTBodies self + = liftIO + (maybeNull (makeNewGObject mkHTMLCollection) + ({# call webkit_dom_html_table_element_get_t_bodies #} + (toHTMLTableElement self))) -htmlTableElementSetAlign :: - (HTMLTableElementClass self) => self -> String -> IO () -htmlTableElementSetAlign self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_table_element_set_align #} - (toHTMLTableElement self) - valPtr +setAlign :: + (MonadIO m, HTMLTableElementClass self, GlibString string) => + self -> string -> m () +setAlign self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_table_element_set_align #} + (toHTMLTableElement self) + valPtr) -htmlTableElementGetAlign :: - (HTMLTableElementClass self) => self -> IO String -htmlTableElementGetAlign self - = ({# call webkit_dom_html_table_element_get_align #} - (toHTMLTableElement self)) - >>= - readUTFString +getAlign :: + (MonadIO m, HTMLTableElementClass self, GlibString string) => + self -> m string +getAlign self + = liftIO + (({# call webkit_dom_html_table_element_get_align #} + (toHTMLTableElement self)) + >>= + readUTFString) -htmlTableElementSetBgColor :: - (HTMLTableElementClass self) => self -> String -> IO () -htmlTableElementSetBgColor self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_table_element_set_bg_color #} - (toHTMLTableElement self) - valPtr +setBgColor :: + (MonadIO m, HTMLTableElementClass self, GlibString string) => + self -> string -> m () +setBgColor self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_table_element_set_bg_color #} + (toHTMLTableElement self) + valPtr) -htmlTableElementGetBgColor :: - (HTMLTableElementClass self) => self -> IO String -htmlTableElementGetBgColor self - = ({# call webkit_dom_html_table_element_get_bg_color #} - (toHTMLTableElement self)) - >>= - readUTFString +getBgColor :: + (MonadIO m, HTMLTableElementClass self, GlibString string) => + self -> m string +getBgColor self + = liftIO + (({# call webkit_dom_html_table_element_get_bg_color #} + (toHTMLTableElement self)) + >>= + readUTFString) -htmlTableElementSetBorder :: - (HTMLTableElementClass self) => self -> String -> IO () -htmlTableElementSetBorder self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_table_element_set_border #} - (toHTMLTableElement self) - valPtr +setBorder :: + (MonadIO m, HTMLTableElementClass self, GlibString string) => + self -> string -> m () +setBorder self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_table_element_set_border #} + (toHTMLTableElement self) + valPtr) -htmlTableElementGetBorder :: - (HTMLTableElementClass self) => self -> IO String -htmlTableElementGetBorder self - = ({# call webkit_dom_html_table_element_get_border #} - (toHTMLTableElement self)) - >>= - readUTFString +getBorder :: + (MonadIO m, HTMLTableElementClass self, GlibString string) => + self -> m string +getBorder self + = liftIO + (({# call webkit_dom_html_table_element_get_border #} + (toHTMLTableElement self)) + >>= + readUTFString) -htmlTableElementSetCellPadding :: - (HTMLTableElementClass self) => self -> String -> IO () -htmlTableElementSetCellPadding self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_table_element_set_cell_padding #} - (toHTMLTableElement self) - valPtr +setCellPadding :: + (MonadIO m, HTMLTableElementClass self, GlibString string) => + self -> string -> m () +setCellPadding self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_table_element_set_cell_padding #} + (toHTMLTableElement self) + valPtr) -htmlTableElementGetCellPadding :: - (HTMLTableElementClass self) => self -> IO String -htmlTableElementGetCellPadding self - = ({# call webkit_dom_html_table_element_get_cell_padding #} - (toHTMLTableElement self)) - >>= - readUTFString +getCellPadding :: + (MonadIO m, HTMLTableElementClass self, GlibString string) => + self -> m string +getCellPadding self + = liftIO + (({# call webkit_dom_html_table_element_get_cell_padding #} + (toHTMLTableElement self)) + >>= + readUTFString) -htmlTableElementSetCellSpacing :: - (HTMLTableElementClass self) => self -> String -> IO () -htmlTableElementSetCellSpacing self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_table_element_set_cell_spacing #} - (toHTMLTableElement self) - valPtr +setCellSpacing :: + (MonadIO m, HTMLTableElementClass self, GlibString string) => + self -> string -> m () +setCellSpacing self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_table_element_set_cell_spacing #} + (toHTMLTableElement self) + valPtr) -htmlTableElementGetCellSpacing :: - (HTMLTableElementClass self) => self -> IO String -htmlTableElementGetCellSpacing self - = ({# call webkit_dom_html_table_element_get_cell_spacing #} - (toHTMLTableElement self)) - >>= - readUTFString +getCellSpacing :: + (MonadIO m, HTMLTableElementClass self, GlibString string) => + self -> m string +getCellSpacing self + = liftIO + (({# call webkit_dom_html_table_element_get_cell_spacing #} + (toHTMLTableElement self)) + >>= + readUTFString) -htmlTableElementSetFrame :: - (HTMLTableElementClass self) => self -> String -> IO () -htmlTableElementSetFrame self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_table_element_set_frame #} - (toHTMLTableElement self) - valPtr +setFrame :: + (MonadIO m, HTMLTableElementClass self, GlibString string) => + self -> string -> m () +setFrame self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_table_element_set_frame #} + (toHTMLTableElement self) + valPtr) -htmlTableElementGetFrame :: - (HTMLTableElementClass self) => self -> IO String -htmlTableElementGetFrame self - = ({# call webkit_dom_html_table_element_get_frame #} - (toHTMLTableElement self)) - >>= - readUTFString +getFrame :: + (MonadIO m, HTMLTableElementClass self, GlibString string) => + self -> m string +getFrame self + = liftIO + (({# call webkit_dom_html_table_element_get_frame #} + (toHTMLTableElement self)) + >>= + readUTFString) -htmlTableElementSetRules :: - (HTMLTableElementClass self) => self -> String -> IO () -htmlTableElementSetRules self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_table_element_set_rules #} - (toHTMLTableElement self) - valPtr +setRules :: + (MonadIO m, HTMLTableElementClass self, GlibString string) => + self -> string -> m () +setRules self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_table_element_set_rules #} + (toHTMLTableElement self) + valPtr) -htmlTableElementGetRules :: - (HTMLTableElementClass self) => self -> IO String -htmlTableElementGetRules self - = ({# call webkit_dom_html_table_element_get_rules #} - (toHTMLTableElement self)) - >>= - readUTFString +getRules :: + (MonadIO m, HTMLTableElementClass self, GlibString string) => + self -> m string +getRules self + = liftIO + (({# call webkit_dom_html_table_element_get_rules #} + (toHTMLTableElement self)) + >>= + readUTFString) -htmlTableElementSetSummary :: - (HTMLTableElementClass self) => self -> String -> IO () -htmlTableElementSetSummary self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_table_element_set_summary #} - (toHTMLTableElement self) - valPtr +setSummary :: + (MonadIO m, HTMLTableElementClass self, GlibString string) => + self -> string -> m () +setSummary self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_table_element_set_summary #} + (toHTMLTableElement self) + valPtr) -htmlTableElementGetSummary :: - (HTMLTableElementClass self) => self -> IO String -htmlTableElementGetSummary self - = ({# call webkit_dom_html_table_element_get_summary #} - (toHTMLTableElement self)) - >>= - readUTFString +getSummary :: + (MonadIO m, HTMLTableElementClass self, GlibString string) => + self -> m string +getSummary self + = liftIO + (({# call webkit_dom_html_table_element_get_summary #} + (toHTMLTableElement self)) + >>= + readUTFString) -htmlTableElementSetWidth :: - (HTMLTableElementClass self) => self -> String -> IO () -htmlTableElementSetWidth self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_table_element_set_width #} - (toHTMLTableElement self) - valPtr +setWidth :: + (MonadIO m, HTMLTableElementClass self, GlibString string) => + self -> string -> m () +setWidth self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_table_element_set_width #} + (toHTMLTableElement self) + valPtr) -htmlTableElementGetWidth :: - (HTMLTableElementClass self) => self -> IO String -htmlTableElementGetWidth self - = ({# call webkit_dom_html_table_element_get_width #} - (toHTMLTableElement self)) - >>= - readUTFString +getWidth :: + (MonadIO m, HTMLTableElementClass self, GlibString string) => + self -> m string +getWidth self + = liftIO + (({# call webkit_dom_html_table_element_get_width #} + (toHTMLTableElement self)) + >>= + readUTFString) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLTableRowElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLTableRowElement.chs --- a/Graphics/UI/Gtk/WebKit/DOM/HTMLTableRowElement.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLTableRowElement.chs @@ -1,148 +1,190 @@ -module Graphics.UI.Gtk.WebKit.DOM.HTMLTableRowElement - (htmlTableRowElementInsertCell, htmlTableRowElementDeleteCell, - htmlTableRowElementGetRowIndex, - htmlTableRowElementGetSectionRowIndex, htmlTableRowElementGetCells, - htmlTableRowElementSetAlign, htmlTableRowElementGetAlign, - htmlTableRowElementSetBgColor, htmlTableRowElementGetBgColor, - htmlTableRowElementSetCh, htmlTableRowElementGetCh, - htmlTableRowElementSetChOff, htmlTableRowElementGetChOff, - htmlTableRowElementSetVAlign, htmlTableRowElementGetVAlign, - HTMLTableRowElement, HTMLTableRowElementClass, - castToHTMLTableRowElement, gTypeHTMLTableRowElement, - toHTMLTableRowElement) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.HTMLTableRowElement( +insertCell, +deleteCell, +getRowIndex, +getSectionRowIndex, +getCells, +setAlign, +getAlign, +setBgColor, +getBgColor, +setCh, +getCh, +setChOff, +getChOff, +setVAlign, +getVAlign, +HTMLTableRowElement, +castToHTMLTableRowElement, +gTypeHTMLTableRowElement, +HTMLTableRowElementClass, +toHTMLTableRowElement, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -htmlTableRowElementInsertCell :: - (HTMLTableRowElementClass self) => - self -> Int -> IO (Maybe HTMLElement) -htmlTableRowElementInsertCell self index - = maybeNull (makeNewGObject mkHTMLElement) +insertCell :: + (MonadIO m, HTMLTableRowElementClass self) => + self -> Int -> m (Maybe HTMLElement) +insertCell self index + = liftIO + (maybeNull (makeNewGObject mkHTMLElement) + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_html_table_row_element_insert_cell #} + (toHTMLTableRowElement self) + (fromIntegral index) + errorPtr_)) + +deleteCell :: + (MonadIO m, HTMLTableRowElementClass self) => self -> Int -> m () +deleteCell self index + = liftIO (propagateGError $ \ errorPtr_ -> - {# call webkit_dom_html_table_row_element_insert_cell #} + {# call webkit_dom_html_table_row_element_delete_cell #} (toHTMLTableRowElement self) (fromIntegral index) errorPtr_) -htmlTableRowElementDeleteCell :: - (HTMLTableRowElementClass self) => self -> Int -> IO () -htmlTableRowElementDeleteCell self index - = propagateGError $ - \ errorPtr_ -> - {# call webkit_dom_html_table_row_element_delete_cell #} - (toHTMLTableRowElement self) - (fromIntegral index) - errorPtr_ - -htmlTableRowElementGetRowIndex :: - (HTMLTableRowElementClass self) => self -> IO Int -htmlTableRowElementGetRowIndex self - = fromIntegral <$> - ({# call webkit_dom_html_table_row_element_get_row_index #} - (toHTMLTableRowElement self)) +getRowIndex :: + (MonadIO m, HTMLTableRowElementClass self) => self -> m Int +getRowIndex self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_table_row_element_get_row_index #} + (toHTMLTableRowElement self))) -htmlTableRowElementGetSectionRowIndex :: - (HTMLTableRowElementClass self) => self -> IO Int -htmlTableRowElementGetSectionRowIndex self - = fromIntegral <$> - ({# call webkit_dom_html_table_row_element_get_section_row_index #} - (toHTMLTableRowElement self)) +getSectionRowIndex :: + (MonadIO m, HTMLTableRowElementClass self) => self -> m Int +getSectionRowIndex self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_table_row_element_get_section_row_index #} + (toHTMLTableRowElement self))) -htmlTableRowElementGetCells :: - (HTMLTableRowElementClass self) => - self -> IO (Maybe HTMLCollection) -htmlTableRowElementGetCells self - = maybeNull (makeNewGObject mkHTMLCollection) - ({# call webkit_dom_html_table_row_element_get_cells #} - (toHTMLTableRowElement self)) +getCells :: + (MonadIO m, HTMLTableRowElementClass self) => + self -> m (Maybe HTMLCollection) +getCells self + = liftIO + (maybeNull (makeNewGObject mkHTMLCollection) + ({# call webkit_dom_html_table_row_element_get_cells #} + (toHTMLTableRowElement self))) -htmlTableRowElementSetAlign :: - (HTMLTableRowElementClass self) => self -> String -> IO () -htmlTableRowElementSetAlign self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_table_row_element_set_align #} - (toHTMLTableRowElement self) - valPtr +setAlign :: + (MonadIO m, HTMLTableRowElementClass self, GlibString string) => + self -> string -> m () +setAlign self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_table_row_element_set_align #} + (toHTMLTableRowElement self) + valPtr) -htmlTableRowElementGetAlign :: - (HTMLTableRowElementClass self) => self -> IO String -htmlTableRowElementGetAlign self - = ({# call webkit_dom_html_table_row_element_get_align #} - (toHTMLTableRowElement self)) - >>= - readUTFString +getAlign :: + (MonadIO m, HTMLTableRowElementClass self, GlibString string) => + self -> m string +getAlign self + = liftIO + (({# call webkit_dom_html_table_row_element_get_align #} + (toHTMLTableRowElement self)) + >>= + readUTFString) -htmlTableRowElementSetBgColor :: - (HTMLTableRowElementClass self) => self -> String -> IO () -htmlTableRowElementSetBgColor self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_table_row_element_set_bg_color #} - (toHTMLTableRowElement self) - valPtr +setBgColor :: + (MonadIO m, HTMLTableRowElementClass self, GlibString string) => + self -> string -> m () +setBgColor self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_table_row_element_set_bg_color #} + (toHTMLTableRowElement self) + valPtr) -htmlTableRowElementGetBgColor :: - (HTMLTableRowElementClass self) => self -> IO String -htmlTableRowElementGetBgColor self - = ({# call webkit_dom_html_table_row_element_get_bg_color #} - (toHTMLTableRowElement self)) - >>= - readUTFString +getBgColor :: + (MonadIO m, HTMLTableRowElementClass self, GlibString string) => + self -> m string +getBgColor self + = liftIO + (({# call webkit_dom_html_table_row_element_get_bg_color #} + (toHTMLTableRowElement self)) + >>= + readUTFString) -htmlTableRowElementSetCh :: - (HTMLTableRowElementClass self) => self -> String -> IO () -htmlTableRowElementSetCh self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_table_row_element_set_ch #} - (toHTMLTableRowElement self) - valPtr +setCh :: + (MonadIO m, HTMLTableRowElementClass self, GlibString string) => + self -> string -> m () +setCh self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_table_row_element_set_ch #} + (toHTMLTableRowElement self) + valPtr) -htmlTableRowElementGetCh :: - (HTMLTableRowElementClass self) => self -> IO String -htmlTableRowElementGetCh self - = ({# call webkit_dom_html_table_row_element_get_ch #} - (toHTMLTableRowElement self)) - >>= - readUTFString +getCh :: + (MonadIO m, HTMLTableRowElementClass self, GlibString string) => + self -> m string +getCh self + = liftIO + (({# call webkit_dom_html_table_row_element_get_ch #} + (toHTMLTableRowElement self)) + >>= + readUTFString) -htmlTableRowElementSetChOff :: - (HTMLTableRowElementClass self) => self -> String -> IO () -htmlTableRowElementSetChOff self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_table_row_element_set_ch_off #} - (toHTMLTableRowElement self) - valPtr +setChOff :: + (MonadIO m, HTMLTableRowElementClass self, GlibString string) => + self -> string -> m () +setChOff self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_table_row_element_set_ch_off #} + (toHTMLTableRowElement self) + valPtr) -htmlTableRowElementGetChOff :: - (HTMLTableRowElementClass self) => self -> IO String -htmlTableRowElementGetChOff self - = ({# call webkit_dom_html_table_row_element_get_ch_off #} - (toHTMLTableRowElement self)) - >>= - readUTFString +getChOff :: + (MonadIO m, HTMLTableRowElementClass self, GlibString string) => + self -> m string +getChOff self + = liftIO + (({# call webkit_dom_html_table_row_element_get_ch_off #} + (toHTMLTableRowElement self)) + >>= + readUTFString) -htmlTableRowElementSetVAlign :: - (HTMLTableRowElementClass self) => self -> String -> IO () -htmlTableRowElementSetVAlign self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_table_row_element_set_v_align #} - (toHTMLTableRowElement self) - valPtr +setVAlign :: + (MonadIO m, HTMLTableRowElementClass self, GlibString string) => + self -> string -> m () +setVAlign self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_table_row_element_set_v_align #} + (toHTMLTableRowElement self) + valPtr) -htmlTableRowElementGetVAlign :: - (HTMLTableRowElementClass self) => self -> IO String -htmlTableRowElementGetVAlign self - = ({# call webkit_dom_html_table_row_element_get_v_align #} - (toHTMLTableRowElement self)) - >>= - readUTFString +getVAlign :: + (MonadIO m, HTMLTableRowElementClass self, GlibString string) => + self -> m string +getVAlign self + = liftIO + (({# call webkit_dom_html_table_row_element_get_v_align #} + (toHTMLTableRowElement self)) + >>= + readUTFString) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLTableSectionElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLTableSectionElement.chs --- a/Graphics/UI/Gtk/WebKit/DOM/HTMLTableSectionElement.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLTableSectionElement.chs @@ -1,115 +1,158 @@ -module Graphics.UI.Gtk.WebKit.DOM.HTMLTableSectionElement - (htmlTableSectionElementInsertRow, - htmlTableSectionElementDeleteRow, htmlTableSectionElementSetAlign, - htmlTableSectionElementGetAlign, htmlTableSectionElementSetCh, - htmlTableSectionElementGetCh, htmlTableSectionElementSetChOff, - htmlTableSectionElementGetChOff, htmlTableSectionElementSetVAlign, - htmlTableSectionElementGetVAlign, htmlTableSectionElementGetRows, - HTMLTableSectionElement, HTMLTableSectionElementClass, - castToHTMLTableSectionElement, gTypeHTMLTableSectionElement, - toHTMLTableSectionElement) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.HTMLTableSectionElement( +insertRow, +deleteRow, +setAlign, +getAlign, +setCh, +getCh, +setChOff, +getChOff, +setVAlign, +getVAlign, +getRows, +HTMLTableSectionElement, +castToHTMLTableSectionElement, +gTypeHTMLTableSectionElement, +HTMLTableSectionElementClass, +toHTMLTableSectionElement, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -htmlTableSectionElementInsertRow :: - (HTMLTableSectionElementClass self) => - self -> Int -> IO (Maybe HTMLElement) -htmlTableSectionElementInsertRow self index - = maybeNull (makeNewGObject mkHTMLElement) +insertRow :: + (MonadIO m, HTMLTableSectionElementClass self) => + self -> Int -> m (Maybe HTMLElement) +insertRow self index + = liftIO + (maybeNull (makeNewGObject mkHTMLElement) + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_html_table_section_element_insert_row #} + (toHTMLTableSectionElement self) + (fromIntegral index) + errorPtr_)) + +deleteRow :: + (MonadIO m, HTMLTableSectionElementClass self) => + self -> Int -> m () +deleteRow self index + = liftIO (propagateGError $ \ errorPtr_ -> - {# call webkit_dom_html_table_section_element_insert_row #} + {# call webkit_dom_html_table_section_element_delete_row #} (toHTMLTableSectionElement self) (fromIntegral index) errorPtr_) -htmlTableSectionElementDeleteRow :: - (HTMLTableSectionElementClass self) => self -> Int -> IO () -htmlTableSectionElementDeleteRow self index - = propagateGError $ - \ errorPtr_ -> - {# call webkit_dom_html_table_section_element_delete_row #} - (toHTMLTableSectionElement self) - (fromIntegral index) - errorPtr_ - -htmlTableSectionElementSetAlign :: - (HTMLTableSectionElementClass self) => self -> String -> IO () -htmlTableSectionElementSetAlign self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_table_section_element_set_align #} - (toHTMLTableSectionElement self) - valPtr +setAlign :: + (MonadIO m, HTMLTableSectionElementClass self, + GlibString string) => + self -> string -> m () +setAlign self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_table_section_element_set_align #} + (toHTMLTableSectionElement self) + valPtr) -htmlTableSectionElementGetAlign :: - (HTMLTableSectionElementClass self) => self -> IO String -htmlTableSectionElementGetAlign self - = ({# call webkit_dom_html_table_section_element_get_align #} - (toHTMLTableSectionElement self)) - >>= - readUTFString +getAlign :: + (MonadIO m, HTMLTableSectionElementClass self, + GlibString string) => + self -> m string +getAlign self + = liftIO + (({# call webkit_dom_html_table_section_element_get_align #} + (toHTMLTableSectionElement self)) + >>= + readUTFString) -htmlTableSectionElementSetCh :: - (HTMLTableSectionElementClass self) => self -> String -> IO () -htmlTableSectionElementSetCh self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_table_section_element_set_ch #} - (toHTMLTableSectionElement self) - valPtr +setCh :: + (MonadIO m, HTMLTableSectionElementClass self, + GlibString string) => + self -> string -> m () +setCh self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_table_section_element_set_ch #} + (toHTMLTableSectionElement self) + valPtr) -htmlTableSectionElementGetCh :: - (HTMLTableSectionElementClass self) => self -> IO String -htmlTableSectionElementGetCh self - = ({# call webkit_dom_html_table_section_element_get_ch #} - (toHTMLTableSectionElement self)) - >>= - readUTFString +getCh :: + (MonadIO m, HTMLTableSectionElementClass self, + GlibString string) => + self -> m string +getCh self + = liftIO + (({# call webkit_dom_html_table_section_element_get_ch #} + (toHTMLTableSectionElement self)) + >>= + readUTFString) -htmlTableSectionElementSetChOff :: - (HTMLTableSectionElementClass self) => self -> String -> IO () -htmlTableSectionElementSetChOff self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_table_section_element_set_ch_off #} - (toHTMLTableSectionElement self) - valPtr +setChOff :: + (MonadIO m, HTMLTableSectionElementClass self, + GlibString string) => + self -> string -> m () +setChOff self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_table_section_element_set_ch_off #} + (toHTMLTableSectionElement self) + valPtr) -htmlTableSectionElementGetChOff :: - (HTMLTableSectionElementClass self) => self -> IO String -htmlTableSectionElementGetChOff self - = ({# call webkit_dom_html_table_section_element_get_ch_off #} - (toHTMLTableSectionElement self)) - >>= - readUTFString +getChOff :: + (MonadIO m, HTMLTableSectionElementClass self, + GlibString string) => + self -> m string +getChOff self + = liftIO + (({# call webkit_dom_html_table_section_element_get_ch_off #} + (toHTMLTableSectionElement self)) + >>= + readUTFString) -htmlTableSectionElementSetVAlign :: - (HTMLTableSectionElementClass self) => self -> String -> IO () -htmlTableSectionElementSetVAlign self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_table_section_element_set_v_align #} - (toHTMLTableSectionElement self) - valPtr +setVAlign :: + (MonadIO m, HTMLTableSectionElementClass self, + GlibString string) => + self -> string -> m () +setVAlign self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_table_section_element_set_v_align #} + (toHTMLTableSectionElement self) + valPtr) -htmlTableSectionElementGetVAlign :: - (HTMLTableSectionElementClass self) => self -> IO String -htmlTableSectionElementGetVAlign self - = ({# call webkit_dom_html_table_section_element_get_v_align #} - (toHTMLTableSectionElement self)) - >>= - readUTFString +getVAlign :: + (MonadIO m, HTMLTableSectionElementClass self, + GlibString string) => + self -> m string +getVAlign self + = liftIO + (({# call webkit_dom_html_table_section_element_get_v_align #} + (toHTMLTableSectionElement self)) + >>= + readUTFString) -htmlTableSectionElementGetRows :: - (HTMLTableSectionElementClass self) => - self -> IO (Maybe HTMLCollection) -htmlTableSectionElementGetRows self - = maybeNull (makeNewGObject mkHTMLCollection) - ({# call webkit_dom_html_table_section_element_get_rows #} - (toHTMLTableSectionElement self)) +getRows :: + (MonadIO m, HTMLTableSectionElementClass self) => + self -> m (Maybe HTMLCollection) +getRows self + = liftIO + (maybeNull (makeNewGObject mkHTMLCollection) + ({# call webkit_dom_html_table_section_element_get_rows #} + (toHTMLTableSectionElement self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLTextAreaElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLTextAreaElement.chs --- a/Graphics/UI/Gtk/WebKit/DOM/HTMLTextAreaElement.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLTextAreaElement.chs @@ -1,389 +1,521 @@ -module Graphics.UI.Gtk.WebKit.DOM.HTMLTextAreaElement - (htmlTextAreaElementCheckValidity, - htmlTextAreaElementSetCustomValidity, htmlTextAreaElementSelect, +module Graphics.UI.Gtk.WebKit.DOM.HTMLTextAreaElement( +checkValidity, +setCustomValidity, +select, #if WEBKIT_CHECK_VERSION(2,2,2) - htmlTextAreaElementSetRangeText, +setRangeText4, #endif - htmlTextAreaElementSetSelectionRange, - htmlTextAreaElementSetAutofocus, htmlTextAreaElementGetAutofocus, - htmlTextAreaElementSetCols, htmlTextAreaElementGetCols, - htmlTextAreaElementSetDirName, htmlTextAreaElementGetDirName, - htmlTextAreaElementSetDisabled, htmlTextAreaElementGetDisabled, - htmlTextAreaElementGetForm, htmlTextAreaElementSetMaxLength, - htmlTextAreaElementGetMaxLength, htmlTextAreaElementSetName, - htmlTextAreaElementGetName, htmlTextAreaElementSetPlaceholder, - htmlTextAreaElementGetPlaceholder, htmlTextAreaElementSetReadOnly, - htmlTextAreaElementGetReadOnly, htmlTextAreaElementSetRequired, - htmlTextAreaElementGetRequired, htmlTextAreaElementSetRows, - htmlTextAreaElementGetRows, htmlTextAreaElementSetWrap, - htmlTextAreaElementGetWrap, htmlTextAreaElementSetDefaultValue, - htmlTextAreaElementGetDefaultValue, htmlTextAreaElementSetValue, - htmlTextAreaElementGetValue, htmlTextAreaElementGetTextLength, - htmlTextAreaElementGetWillValidate, htmlTextAreaElementGetValidity, - htmlTextAreaElementGetValidationMessage, - htmlTextAreaElementGetLabels, htmlTextAreaElementSetSelectionStart, - htmlTextAreaElementGetSelectionStart, - htmlTextAreaElementSetSelectionEnd, - htmlTextAreaElementGetSelectionEnd, - htmlTextAreaElementSetSelectionDirection, - htmlTextAreaElementGetSelectionDirection, HTMLTextAreaElement, - HTMLTextAreaElementClass, castToHTMLTextAreaElement, - gTypeHTMLTextAreaElement, toHTMLTextAreaElement) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +setSelectionRange, +setAutofocus, +getAutofocus, +setCols, +getCols, +setDirName, +getDirName, +setDisabled, +getDisabled, +getForm, +setMaxLength, +getMaxLength, +setName, +getName, +setPlaceholder, +getPlaceholder, +setReadOnly, +getReadOnly, +setRequired, +getRequired, +setRows, +getRows, +setWrap, +getWrap, +setDefaultValue, +getDefaultValue, +setValue, +getValue, +getTextLength, +getWillValidate, +getValidity, +getValidationMessage, +getLabels, +setSelectionStart, +getSelectionStart, +setSelectionEnd, +getSelectionEnd, +setSelectionDirection, +getSelectionDirection, +#if WEBKIT_CHECK_VERSION(2,4,0) +setAutocorrect, +getAutocorrect, +setAutocapitalize, +getAutocapitalize, +#endif +HTMLTextAreaElement, +castToHTMLTextAreaElement, +gTypeHTMLTextAreaElement, +HTMLTextAreaElementClass, +toHTMLTextAreaElement, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM - -htmlTextAreaElementCheckValidity :: - (HTMLTextAreaElementClass self) => self -> IO Bool -htmlTextAreaElementCheckValidity self - = toBool <$> - ({# call webkit_dom_html_text_area_element_check_validity #} - (toHTMLTextAreaElement self)) +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -htmlTextAreaElementSetCustomValidity :: - (HTMLTextAreaElementClass self) => self -> String -> IO () -htmlTextAreaElementSetCustomValidity self error - = withUTFString error $ - \ errorPtr -> - {# call webkit_dom_html_text_area_element_set_custom_validity #} - (toHTMLTextAreaElement self) - errorPtr +checkValidity :: + (MonadIO m, HTMLTextAreaElementClass self) => self -> m Bool +checkValidity self + = liftIO + (toBool <$> + ({# call webkit_dom_html_text_area_element_check_validity #} + (toHTMLTextAreaElement self))) -htmlTextAreaElementSelect :: - (HTMLTextAreaElementClass self) => self -> IO () -htmlTextAreaElementSelect self - = {# call webkit_dom_html_text_area_element_select #} - (toHTMLTextAreaElement self) +setCustomValidity :: + (MonadIO m, HTMLTextAreaElementClass self, GlibString string) => + self -> (Maybe string) -> m () +setCustomValidity self error + = liftIO + (maybeWith withUTFString error $ + \ errorPtr -> + {# call webkit_dom_html_text_area_element_set_custom_validity #} + (toHTMLTextAreaElement self) + errorPtr) -#if WEBKIT_CHECK_VERSION(2,2,2) -htmlTextAreaElementSetRangeText :: - (HTMLTextAreaElementClass self) => - self -> String -> Word -> Word -> String -> IO () -htmlTextAreaElementSetRangeText self replacement start end - selectionMode - = propagateGError $ - \ errorPtr_ -> - withUTFString selectionMode $ - \ selectionModePtr -> - withUTFString replacement $ - \ replacementPtr -> - {# call webkit_dom_html_text_area_element_set_range_text #} - (toHTMLTextAreaElement self) - replacementPtr - (fromIntegral start) - (fromIntegral end) - selectionModePtr - errorPtr_ -#endif +select :: + (MonadIO m, HTMLTextAreaElementClass self) => self -> m () +select self + = liftIO + ({# call webkit_dom_html_text_area_element_select #} + (toHTMLTextAreaElement self)) -htmlTextAreaElementSetSelectionRange :: - (HTMLTextAreaElementClass self) => - self -> Int -> Int -> String -> IO () -htmlTextAreaElementSetSelectionRange self start end direction - = withUTFString direction $ - \ directionPtr -> - {# call webkit_dom_html_text_area_element_set_selection_range #} - (toHTMLTextAreaElement self) - (fromIntegral start) - (fromIntegral end) - directionPtr +#if WEBKIT_CHECK_VERSION(2,2,2) +setRangeText4 :: + (MonadIO m, HTMLTextAreaElementClass self, GlibString string) => + self -> string -> Word -> Word -> string -> m () +setRangeText4 self replacement start end selectionMode + = liftIO + (propagateGError $ + \ errorPtr_ -> + withUTFString selectionMode $ + \ selectionModePtr -> + withUTFString replacement $ + \ replacementPtr -> + {# call webkit_dom_html_text_area_element_set_range_text #} + (toHTMLTextAreaElement self) + replacementPtr + (fromIntegral start) + (fromIntegral end) + selectionModePtr + errorPtr_) +#endif -htmlTextAreaElementSetAutofocus :: - (HTMLTextAreaElementClass self) => self -> Bool -> IO () -htmlTextAreaElementSetAutofocus self val - = {# call webkit_dom_html_text_area_element_set_autofocus #} - (toHTMLTextAreaElement self) - (fromBool val) +setSelectionRange :: + (MonadIO m, HTMLTextAreaElementClass self, GlibString string) => + self -> Int -> Int -> string -> m () +setSelectionRange self start end direction + = liftIO + (withUTFString direction $ + \ directionPtr -> + {# call webkit_dom_html_text_area_element_set_selection_range #} + (toHTMLTextAreaElement self) + (fromIntegral start) + (fromIntegral end) + directionPtr) -htmlTextAreaElementGetAutofocus :: - (HTMLTextAreaElementClass self) => self -> IO Bool -htmlTextAreaElementGetAutofocus self - = toBool <$> - ({# call webkit_dom_html_text_area_element_get_autofocus #} - (toHTMLTextAreaElement self)) +setAutofocus :: + (MonadIO m, HTMLTextAreaElementClass self) => self -> Bool -> m () +setAutofocus self val + = liftIO + ({# call webkit_dom_html_text_area_element_set_autofocus #} + (toHTMLTextAreaElement self) + (fromBool val)) -htmlTextAreaElementSetCols :: - (HTMLTextAreaElementClass self) => self -> Int -> IO () -htmlTextAreaElementSetCols self val - = {# call webkit_dom_html_text_area_element_set_cols #} - (toHTMLTextAreaElement self) - (fromIntegral val) +getAutofocus :: + (MonadIO m, HTMLTextAreaElementClass self) => self -> m Bool +getAutofocus self + = liftIO + (toBool <$> + ({# call webkit_dom_html_text_area_element_get_autofocus #} + (toHTMLTextAreaElement self))) -htmlTextAreaElementGetCols :: - (HTMLTextAreaElementClass self) => self -> IO Int -htmlTextAreaElementGetCols self - = fromIntegral <$> - ({# call webkit_dom_html_text_area_element_get_cols #} - (toHTMLTextAreaElement self)) +setCols :: + (MonadIO m, HTMLTextAreaElementClass self) => self -> Int -> m () +setCols self val + = liftIO + ({# call webkit_dom_html_text_area_element_set_cols #} + (toHTMLTextAreaElement self) + (fromIntegral val)) -htmlTextAreaElementSetDirName :: - (HTMLTextAreaElementClass self) => self -> String -> IO () -htmlTextAreaElementSetDirName self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_text_area_element_set_dir_name #} - (toHTMLTextAreaElement self) - valPtr +getCols :: + (MonadIO m, HTMLTextAreaElementClass self) => self -> m Int +getCols self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_text_area_element_get_cols #} + (toHTMLTextAreaElement self))) -htmlTextAreaElementGetDirName :: - (HTMLTextAreaElementClass self) => self -> IO String -htmlTextAreaElementGetDirName self - = ({# call webkit_dom_html_text_area_element_get_dir_name #} - (toHTMLTextAreaElement self)) - >>= - readUTFString +setDirName :: + (MonadIO m, HTMLTextAreaElementClass self, GlibString string) => + self -> string -> m () +setDirName self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_text_area_element_set_dir_name #} + (toHTMLTextAreaElement self) + valPtr) -htmlTextAreaElementSetDisabled :: - (HTMLTextAreaElementClass self) => self -> Bool -> IO () -htmlTextAreaElementSetDisabled self val - = {# call webkit_dom_html_text_area_element_set_disabled #} - (toHTMLTextAreaElement self) - (fromBool val) +getDirName :: + (MonadIO m, HTMLTextAreaElementClass self, GlibString string) => + self -> m string +getDirName self + = liftIO + (({# call webkit_dom_html_text_area_element_get_dir_name #} + (toHTMLTextAreaElement self)) + >>= + readUTFString) -htmlTextAreaElementGetDisabled :: - (HTMLTextAreaElementClass self) => self -> IO Bool -htmlTextAreaElementGetDisabled self - = toBool <$> - ({# call webkit_dom_html_text_area_element_get_disabled #} - (toHTMLTextAreaElement self)) +setDisabled :: + (MonadIO m, HTMLTextAreaElementClass self) => self -> Bool -> m () +setDisabled self val + = liftIO + ({# call webkit_dom_html_text_area_element_set_disabled #} + (toHTMLTextAreaElement self) + (fromBool val)) -htmlTextAreaElementGetForm :: - (HTMLTextAreaElementClass self) => - self -> IO (Maybe HTMLFormElement) -htmlTextAreaElementGetForm self - = maybeNull (makeNewGObject mkHTMLFormElement) - ({# call webkit_dom_html_text_area_element_get_form #} - (toHTMLTextAreaElement self)) +getDisabled :: + (MonadIO m, HTMLTextAreaElementClass self) => self -> m Bool +getDisabled self + = liftIO + (toBool <$> + ({# call webkit_dom_html_text_area_element_get_disabled #} + (toHTMLTextAreaElement self))) -htmlTextAreaElementSetMaxLength :: - (HTMLTextAreaElementClass self) => self -> Int -> IO () -htmlTextAreaElementSetMaxLength self val - = propagateGError $ - \ errorPtr_ -> - {# call webkit_dom_html_text_area_element_set_max_length #} - (toHTMLTextAreaElement self) - (fromIntegral val) - errorPtr_ +getForm :: + (MonadIO m, HTMLTextAreaElementClass self) => + self -> m (Maybe HTMLFormElement) +getForm self + = liftIO + (maybeNull (makeNewGObject mkHTMLFormElement) + ({# call webkit_dom_html_text_area_element_get_form #} + (toHTMLTextAreaElement self))) -htmlTextAreaElementGetMaxLength :: - (HTMLTextAreaElementClass self) => self -> IO Int -htmlTextAreaElementGetMaxLength self - = fromIntegral <$> - ({# call webkit_dom_html_text_area_element_get_max_length #} - (toHTMLTextAreaElement self)) +setMaxLength :: + (MonadIO m, HTMLTextAreaElementClass self) => self -> Int -> m () +setMaxLength self val + = liftIO + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_html_text_area_element_set_max_length #} + (toHTMLTextAreaElement self) + (fromIntegral val) + errorPtr_) -htmlTextAreaElementSetName :: - (HTMLTextAreaElementClass self) => self -> String -> IO () -htmlTextAreaElementSetName self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_text_area_element_set_name #} - (toHTMLTextAreaElement self) - valPtr +getMaxLength :: + (MonadIO m, HTMLTextAreaElementClass self) => self -> m Int +getMaxLength self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_text_area_element_get_max_length #} + (toHTMLTextAreaElement self))) -htmlTextAreaElementGetName :: - (HTMLTextAreaElementClass self) => self -> IO String -htmlTextAreaElementGetName self - = ({# call webkit_dom_html_text_area_element_get_name #} - (toHTMLTextAreaElement self)) - >>= - readUTFString +setName :: + (MonadIO m, HTMLTextAreaElementClass self, GlibString string) => + self -> string -> m () +setName self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_text_area_element_set_name #} + (toHTMLTextAreaElement self) + valPtr) -htmlTextAreaElementSetPlaceholder :: - (HTMLTextAreaElementClass self) => self -> String -> IO () -htmlTextAreaElementSetPlaceholder self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_text_area_element_set_placeholder #} - (toHTMLTextAreaElement self) - valPtr +getName :: + (MonadIO m, HTMLTextAreaElementClass self, GlibString string) => + self -> m string +getName self + = liftIO + (({# call webkit_dom_html_text_area_element_get_name #} + (toHTMLTextAreaElement self)) + >>= + readUTFString) -htmlTextAreaElementGetPlaceholder :: - (HTMLTextAreaElementClass self) => self -> IO String -htmlTextAreaElementGetPlaceholder self - = ({# call webkit_dom_html_text_area_element_get_placeholder #} - (toHTMLTextAreaElement self)) - >>= - readUTFString +setPlaceholder :: + (MonadIO m, HTMLTextAreaElementClass self, GlibString string) => + self -> string -> m () +setPlaceholder self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_text_area_element_set_placeholder #} + (toHTMLTextAreaElement self) + valPtr) -htmlTextAreaElementSetReadOnly :: - (HTMLTextAreaElementClass self) => self -> Bool -> IO () -htmlTextAreaElementSetReadOnly self val - = {# call webkit_dom_html_text_area_element_set_read_only #} - (toHTMLTextAreaElement self) - (fromBool val) +getPlaceholder :: + (MonadIO m, HTMLTextAreaElementClass self, GlibString string) => + self -> m string +getPlaceholder self + = liftIO + (({# call webkit_dom_html_text_area_element_get_placeholder #} + (toHTMLTextAreaElement self)) + >>= + readUTFString) -htmlTextAreaElementGetReadOnly :: - (HTMLTextAreaElementClass self) => self -> IO Bool -htmlTextAreaElementGetReadOnly self - = toBool <$> - ({# call webkit_dom_html_text_area_element_get_read_only #} - (toHTMLTextAreaElement self)) +setReadOnly :: + (MonadIO m, HTMLTextAreaElementClass self) => self -> Bool -> m () +setReadOnly self val + = liftIO + ({# call webkit_dom_html_text_area_element_set_read_only #} + (toHTMLTextAreaElement self) + (fromBool val)) -htmlTextAreaElementSetRequired :: - (HTMLTextAreaElementClass self) => self -> Bool -> IO () -htmlTextAreaElementSetRequired self val - = {# call webkit_dom_html_text_area_element_set_required #} - (toHTMLTextAreaElement self) - (fromBool val) +getReadOnly :: + (MonadIO m, HTMLTextAreaElementClass self) => self -> m Bool +getReadOnly self + = liftIO + (toBool <$> + ({# call webkit_dom_html_text_area_element_get_read_only #} + (toHTMLTextAreaElement self))) -htmlTextAreaElementGetRequired :: - (HTMLTextAreaElementClass self) => self -> IO Bool -htmlTextAreaElementGetRequired self - = toBool <$> - ({# call webkit_dom_html_text_area_element_get_required #} - (toHTMLTextAreaElement self)) +setRequired :: + (MonadIO m, HTMLTextAreaElementClass self) => self -> Bool -> m () +setRequired self val + = liftIO + ({# call webkit_dom_html_text_area_element_set_required #} + (toHTMLTextAreaElement self) + (fromBool val)) -htmlTextAreaElementSetRows :: - (HTMLTextAreaElementClass self) => self -> Int -> IO () -htmlTextAreaElementSetRows self val - = {# call webkit_dom_html_text_area_element_set_rows #} - (toHTMLTextAreaElement self) - (fromIntegral val) +getRequired :: + (MonadIO m, HTMLTextAreaElementClass self) => self -> m Bool +getRequired self + = liftIO + (toBool <$> + ({# call webkit_dom_html_text_area_element_get_required #} + (toHTMLTextAreaElement self))) -htmlTextAreaElementGetRows :: - (HTMLTextAreaElementClass self) => self -> IO Int -htmlTextAreaElementGetRows self - = fromIntegral <$> - ({# call webkit_dom_html_text_area_element_get_rows #} - (toHTMLTextAreaElement self)) +setRows :: + (MonadIO m, HTMLTextAreaElementClass self) => self -> Int -> m () +setRows self val + = liftIO + ({# call webkit_dom_html_text_area_element_set_rows #} + (toHTMLTextAreaElement self) + (fromIntegral val)) -htmlTextAreaElementSetWrap :: - (HTMLTextAreaElementClass self) => self -> String -> IO () -htmlTextAreaElementSetWrap self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_text_area_element_set_wrap #} - (toHTMLTextAreaElement self) - valPtr +getRows :: + (MonadIO m, HTMLTextAreaElementClass self) => self -> m Int +getRows self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_text_area_element_get_rows #} + (toHTMLTextAreaElement self))) -htmlTextAreaElementGetWrap :: - (HTMLTextAreaElementClass self) => self -> IO String -htmlTextAreaElementGetWrap self - = ({# call webkit_dom_html_text_area_element_get_wrap #} - (toHTMLTextAreaElement self)) - >>= - readUTFString +setWrap :: + (MonadIO m, HTMLTextAreaElementClass self, GlibString string) => + self -> string -> m () +setWrap self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_text_area_element_set_wrap #} + (toHTMLTextAreaElement self) + valPtr) -htmlTextAreaElementSetDefaultValue :: - (HTMLTextAreaElementClass self) => self -> String -> IO () -htmlTextAreaElementSetDefaultValue self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_text_area_element_set_default_value #} - (toHTMLTextAreaElement self) - valPtr +getWrap :: + (MonadIO m, HTMLTextAreaElementClass self, GlibString string) => + self -> m string +getWrap self + = liftIO + (({# call webkit_dom_html_text_area_element_get_wrap #} + (toHTMLTextAreaElement self)) + >>= + readUTFString) -htmlTextAreaElementGetDefaultValue :: - (HTMLTextAreaElementClass self) => self -> IO String -htmlTextAreaElementGetDefaultValue self - = ({# call webkit_dom_html_text_area_element_get_default_value #} - (toHTMLTextAreaElement self)) - >>= - readUTFString +setDefaultValue :: + (MonadIO m, HTMLTextAreaElementClass self, GlibString string) => + self -> (Maybe string) -> m () +setDefaultValue self val + = liftIO + (maybeWith withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_text_area_element_set_default_value #} + (toHTMLTextAreaElement self) + valPtr) -htmlTextAreaElementSetValue :: - (HTMLTextAreaElementClass self) => self -> String -> IO () -htmlTextAreaElementSetValue self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_text_area_element_set_value #} - (toHTMLTextAreaElement self) - valPtr +getDefaultValue :: + (MonadIO m, HTMLTextAreaElementClass self, GlibString string) => + self -> m (Maybe string) +getDefaultValue self + = liftIO + (({# call webkit_dom_html_text_area_element_get_default_value #} + (toHTMLTextAreaElement self)) + >>= + maybePeek readUTFString) -htmlTextAreaElementGetValue :: - (HTMLTextAreaElementClass self) => self -> IO String -htmlTextAreaElementGetValue self - = ({# call webkit_dom_html_text_area_element_get_value #} - (toHTMLTextAreaElement self)) - >>= - readUTFString +setValue :: + (MonadIO m, HTMLTextAreaElementClass self, GlibString string) => + self -> (Maybe string) -> m () +setValue self val + = liftIO + (maybeWith withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_text_area_element_set_value #} + (toHTMLTextAreaElement self) + valPtr) -htmlTextAreaElementGetTextLength :: - (HTMLTextAreaElementClass self) => self -> IO Word -htmlTextAreaElementGetTextLength self - = fromIntegral <$> - ({# call webkit_dom_html_text_area_element_get_text_length #} - (toHTMLTextAreaElement self)) +getValue :: + (MonadIO m, HTMLTextAreaElementClass self, GlibString string) => + self -> m (Maybe string) +getValue self + = liftIO + (({# call webkit_dom_html_text_area_element_get_value #} + (toHTMLTextAreaElement self)) + >>= + maybePeek readUTFString) -htmlTextAreaElementGetWillValidate :: - (HTMLTextAreaElementClass self) => self -> IO Bool -htmlTextAreaElementGetWillValidate self - = toBool <$> - ({# call webkit_dom_html_text_area_element_get_will_validate #} - (toHTMLTextAreaElement self)) +getTextLength :: + (MonadIO m, HTMLTextAreaElementClass self) => self -> m Word +getTextLength self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_text_area_element_get_text_length #} + (toHTMLTextAreaElement self))) -htmlTextAreaElementGetValidity :: - (HTMLTextAreaElementClass self) => self -> IO (Maybe ValidityState) -htmlTextAreaElementGetValidity self - = maybeNull (makeNewGObject mkValidityState) - ({# call webkit_dom_html_text_area_element_get_validity #} - (toHTMLTextAreaElement self)) +getWillValidate :: + (MonadIO m, HTMLTextAreaElementClass self) => self -> m Bool +getWillValidate self + = liftIO + (toBool <$> + ({# call webkit_dom_html_text_area_element_get_will_validate #} + (toHTMLTextAreaElement self))) -htmlTextAreaElementGetValidationMessage :: - (HTMLTextAreaElementClass self) => self -> IO String -htmlTextAreaElementGetValidationMessage self - = ({# call webkit_dom_html_text_area_element_get_validation_message - #} - (toHTMLTextAreaElement self)) - >>= - readUTFString +getValidity :: + (MonadIO m, HTMLTextAreaElementClass self) => + self -> m (Maybe ValidityState) +getValidity self + = liftIO + (maybeNull (makeNewGObject mkValidityState) + ({# call webkit_dom_html_text_area_element_get_validity #} + (toHTMLTextAreaElement self))) -htmlTextAreaElementGetLabels :: - (HTMLTextAreaElementClass self) => self -> IO (Maybe NodeList) -htmlTextAreaElementGetLabels self - = maybeNull (makeNewGObject mkNodeList) - ({# call webkit_dom_html_text_area_element_get_labels #} - (toHTMLTextAreaElement self)) +getValidationMessage :: + (MonadIO m, HTMLTextAreaElementClass self, GlibString string) => + self -> m string +getValidationMessage self + = liftIO + (({# call webkit_dom_html_text_area_element_get_validation_message + #} + (toHTMLTextAreaElement self)) + >>= + readUTFString) -htmlTextAreaElementSetSelectionStart :: - (HTMLTextAreaElementClass self) => self -> Int -> IO () -htmlTextAreaElementSetSelectionStart self val - = {# call webkit_dom_html_text_area_element_set_selection_start #} - (toHTMLTextAreaElement self) - (fromIntegral val) +getLabels :: + (MonadIO m, HTMLTextAreaElementClass self) => + self -> m (Maybe NodeList) +getLabels self + = liftIO + (maybeNull (makeNewGObject mkNodeList) + ({# call webkit_dom_html_text_area_element_get_labels #} + (toHTMLTextAreaElement self))) -htmlTextAreaElementGetSelectionStart :: - (HTMLTextAreaElementClass self) => self -> IO Int -htmlTextAreaElementGetSelectionStart self - = fromIntegral <$> - ({# call webkit_dom_html_text_area_element_get_selection_start #} - (toHTMLTextAreaElement self)) +setSelectionStart :: + (MonadIO m, HTMLTextAreaElementClass self) => self -> Int -> m () +setSelectionStart self val + = liftIO + ({# call webkit_dom_html_text_area_element_set_selection_start #} + (toHTMLTextAreaElement self) + (fromIntegral val)) -htmlTextAreaElementSetSelectionEnd :: - (HTMLTextAreaElementClass self) => self -> Int -> IO () -htmlTextAreaElementSetSelectionEnd self val - = {# call webkit_dom_html_text_area_element_set_selection_end #} - (toHTMLTextAreaElement self) - (fromIntegral val) +getSelectionStart :: + (MonadIO m, HTMLTextAreaElementClass self) => self -> m Int +getSelectionStart self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_text_area_element_get_selection_start #} + (toHTMLTextAreaElement self))) -htmlTextAreaElementGetSelectionEnd :: - (HTMLTextAreaElementClass self) => self -> IO Int -htmlTextAreaElementGetSelectionEnd self - = fromIntegral <$> - ({# call webkit_dom_html_text_area_element_get_selection_end #} - (toHTMLTextAreaElement self)) +setSelectionEnd :: + (MonadIO m, HTMLTextAreaElementClass self) => self -> Int -> m () +setSelectionEnd self val + = liftIO + ({# call webkit_dom_html_text_area_element_set_selection_end #} + (toHTMLTextAreaElement self) + (fromIntegral val)) -htmlTextAreaElementSetSelectionDirection :: - (HTMLTextAreaElementClass self) => self -> String -> IO () -htmlTextAreaElementSetSelectionDirection self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_text_area_element_set_selection_direction +getSelectionEnd :: + (MonadIO m, HTMLTextAreaElementClass self) => self -> m Int +getSelectionEnd self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_text_area_element_get_selection_end #} + (toHTMLTextAreaElement self))) + +setSelectionDirection :: + (MonadIO m, HTMLTextAreaElementClass self, GlibString string) => + self -> string -> m () +setSelectionDirection self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_text_area_element_set_selection_direction + #} + (toHTMLTextAreaElement self) + valPtr) + +getSelectionDirection :: + (MonadIO m, HTMLTextAreaElementClass self, GlibString string) => + self -> m string +getSelectionDirection self + = liftIO + (({# call webkit_dom_html_text_area_element_get_selection_direction #} - (toHTMLTextAreaElement self) - valPtr + (toHTMLTextAreaElement self)) + >>= + readUTFString) + +#if WEBKIT_CHECK_VERSION(2,4,0) +setAutocorrect :: + (MonadIO m, HTMLTextAreaElementClass self) => self -> Bool -> m () +setAutocorrect self val + = liftIO + ({# call webkit_dom_html_text_area_element_set_autocorrect #} + (toHTMLTextAreaElement self) + (fromBool val)) -htmlTextAreaElementGetSelectionDirection :: - (HTMLTextAreaElementClass self) => self -> IO String -htmlTextAreaElementGetSelectionDirection self - = ({# call - webkit_dom_html_text_area_element_get_selection_direction - #} - (toHTMLTextAreaElement self)) - >>= - readUTFString +getAutocorrect :: + (MonadIO m, HTMLTextAreaElementClass self) => self -> m Bool +getAutocorrect self + = liftIO + (toBool <$> + ({# call webkit_dom_html_text_area_element_get_autocorrect #} + (toHTMLTextAreaElement self))) + +setAutocapitalize :: + (MonadIO m, HTMLTextAreaElementClass self, GlibString string) => + self -> (Maybe string) -> m () +setAutocapitalize self val + = liftIO + (maybeWith withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_text_area_element_set_autocapitalize #} + (toHTMLTextAreaElement self) + valPtr) + +getAutocapitalize :: + (MonadIO m, HTMLTextAreaElementClass self, GlibString string) => + self -> m (Maybe string) +getAutocapitalize self + = liftIO + (({# call webkit_dom_html_text_area_element_get_autocapitalize #} + (toHTMLTextAreaElement self)) + >>= + maybePeek readUTFString) +#endif diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLTitleElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLTitleElement.chs --- a/Graphics/UI/Gtk/WebKit/DOM/HTMLTitleElement.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLTitleElement.chs @@ -1,28 +1,44 @@ -module Graphics.UI.Gtk.WebKit.DOM.HTMLTitleElement - (htmlTitleElementSetText, htmlTitleElementGetText, - HTMLTitleElement, HTMLTitleElementClass, castToHTMLTitleElement, - gTypeHTMLTitleElement, toHTMLTitleElement) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.HTMLTitleElement( +setText, +getText, +HTMLTitleElement, +castToHTMLTitleElement, +gTypeHTMLTitleElement, +HTMLTitleElementClass, +toHTMLTitleElement, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -htmlTitleElementSetText :: - (HTMLTitleElementClass self) => self -> String -> IO () -htmlTitleElementSetText self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_title_element_set_text #} - (toHTMLTitleElement self) - valPtr +setText :: + (MonadIO m, HTMLTitleElementClass self, GlibString string) => + self -> (Maybe string) -> m () +setText self val + = liftIO + (maybeWith withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_title_element_set_text #} + (toHTMLTitleElement self) + valPtr) -htmlTitleElementGetText :: - (HTMLTitleElementClass self) => self -> IO String -htmlTitleElementGetText self - = ({# call webkit_dom_html_title_element_get_text #} - (toHTMLTitleElement self)) - >>= - readUTFString +getText :: + (MonadIO m, HTMLTitleElementClass self, GlibString string) => + self -> m (Maybe string) +getText self + = liftIO + (({# call webkit_dom_html_title_element_get_text #} + (toHTMLTitleElement self)) + >>= + maybePeek readUTFString) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLUListElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLUListElement.chs --- a/Graphics/UI/Gtk/WebKit/DOM/HTMLUListElement.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLUListElement.chs @@ -1,25 +1,39 @@ -module Graphics.UI.Gtk.WebKit.DOM.HTMLUListElement - (htmluListElementSetCompact, htmluListElementGetCompact, - HTMLUListElement, HTMLUListElementClass, castToHTMLUListElement, - gTypeHTMLUListElement, toHTMLUListElement) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.HTMLUListElement( +setCompact, +getCompact, +HTMLUListElement, +castToHTMLUListElement, +gTypeHTMLUListElement, +HTMLUListElementClass, +toHTMLUListElement, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -htmluListElementSetCompact :: - (HTMLUListElementClass self) => self -> Bool -> IO () -htmluListElementSetCompact self val - = {# call webkit_dom_htmlu_list_element_set_compact #} - (toHTMLUListElement self) - (fromBool val) +setCompact :: + (MonadIO m, HTMLUListElementClass self) => self -> Bool -> m () +setCompact self val + = liftIO + ({# call webkit_dom_htmlu_list_element_set_compact #} + (toHTMLUListElement self) + (fromBool val)) -htmluListElementGetCompact :: - (HTMLUListElementClass self) => self -> IO Bool -htmluListElementGetCompact self - = toBool <$> - ({# call webkit_dom_htmlu_list_element_get_compact #} - (toHTMLUListElement self)) +getCompact :: + (MonadIO m, HTMLUListElementClass self) => self -> m Bool +getCompact self + = liftIO + (toBool <$> + ({# call webkit_dom_htmlu_list_element_get_compact #} + (toHTMLUListElement self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLVideoElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLVideoElement.chs --- a/Graphics/UI/Gtk/WebKit/DOM/HTMLVideoElement.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLVideoElement.chs @@ -1,147 +1,263 @@ -module Graphics.UI.Gtk.WebKit.DOM.HTMLVideoElement - (htmlVideoElementWebkitEnterFullscreen, - htmlVideoElementWebkitExitFullscreen, - htmlVideoElementWebkitEnterFullScreen, - htmlVideoElementWebkitExitFullScreen, htmlVideoElementSetWidth, - htmlVideoElementGetWidth, htmlVideoElementSetHeight, - htmlVideoElementGetHeight, htmlVideoElementGetVideoWidth, - htmlVideoElementGetVideoHeight, htmlVideoElementSetPoster, - htmlVideoElementGetPoster, - htmlVideoElementGetWebkitSupportsFullscreen, - htmlVideoElementGetWebkitDisplayingFullscreen, - htmlVideoElementGetWebkitDecodedFrameCount, - htmlVideoElementGetWebkitDroppedFrameCount, HTMLVideoElement, - HTMLVideoElementClass, castToHTMLVideoElement, - gTypeHTMLVideoElement, toHTMLVideoElement) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.HTMLVideoElement( +webkitEnterFullscreen, +webkitExitFullscreen, +webkitEnterFullScreen, +webkitExitFullScreen, +#if WEBKIT_CHECK_VERSION(99,0,0) +webkitSupportsPresentationMode, +webkitSetPresentationMode, +#endif +setWidth, +getWidth, +setHeight, +getHeight, +getVideoWidth, +getVideoHeight, +setPoster, +getPoster, +getWebkitSupportsFullscreen, +getWebkitDisplayingFullscreen, +#if WEBKIT_CHECK_VERSION(2,4,0) +setWebkitWirelessVideoPlaybackDisabled, +getWebkitWirelessVideoPlaybackDisabled, +#endif +getWebkitDecodedFrameCount, +getWebkitDroppedFrameCount, +#if WEBKIT_CHECK_VERSION(99,0,0) +getWebkitPresentationMode, +#endif +webKitPresentationModeChanged, +HTMLVideoElement, +castToHTMLVideoElement, +gTypeHTMLVideoElement, +HTMLVideoElementClass, +toHTMLVideoElement, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -htmlVideoElementWebkitEnterFullscreen :: - (HTMLVideoElementClass self) => self -> IO () -htmlVideoElementWebkitEnterFullscreen self - = propagateGError $ - \ errorPtr_ -> - {# call webkit_dom_html_video_element_webkit_enter_fullscreen #} - (toHTMLVideoElement self) - errorPtr_ +webkitEnterFullscreen :: + (MonadIO m, HTMLVideoElementClass self) => self -> m () +webkitEnterFullscreen self + = liftIO + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_html_video_element_webkit_enter_fullscreen #} + (toHTMLVideoElement self) + errorPtr_) -htmlVideoElementWebkitExitFullscreen :: - (HTMLVideoElementClass self) => self -> IO () -htmlVideoElementWebkitExitFullscreen self - = {# call webkit_dom_html_video_element_webkit_exit_fullscreen #} - (toHTMLVideoElement self) +webkitExitFullscreen :: + (MonadIO m, HTMLVideoElementClass self) => self -> m () +webkitExitFullscreen self + = liftIO + ({# call webkit_dom_html_video_element_webkit_exit_fullscreen #} + (toHTMLVideoElement self)) -htmlVideoElementWebkitEnterFullScreen :: - (HTMLVideoElementClass self) => self -> IO () -htmlVideoElementWebkitEnterFullScreen self - = propagateGError $ - \ errorPtr_ -> - {# call webkit_dom_html_video_element_webkit_enter_full_screen #} - (toHTMLVideoElement self) - errorPtr_ +webkitEnterFullScreen :: + (MonadIO m, HTMLVideoElementClass self) => self -> m () +webkitEnterFullScreen self + = liftIO + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_html_video_element_webkit_enter_full_screen #} + (toHTMLVideoElement self) + errorPtr_) -htmlVideoElementWebkitExitFullScreen :: - (HTMLVideoElementClass self) => self -> IO () -htmlVideoElementWebkitExitFullScreen self - = {# call webkit_dom_html_video_element_webkit_exit_full_screen #} - (toHTMLVideoElement self) +webkitExitFullScreen :: + (MonadIO m, HTMLVideoElementClass self) => self -> m () +webkitExitFullScreen self + = liftIO + ({# call webkit_dom_html_video_element_webkit_exit_full_screen #} + (toHTMLVideoElement self)) + +#if WEBKIT_CHECK_VERSION(99,0,0) +webkitSupportsPresentationMode :: + (MonadIO m, HTMLVideoElementClass self) => + self -> VideoPresentationMode -> m Bool +webkitSupportsPresentationMode self mode + = liftIO + (toBool <$> + (withUTFString (enumToString mode) $ + \ modePtr -> + {# call + webkit_dom_html_video_element_webkit_supports_presentation_mode + #} + (toHTMLVideoElement self) + modePtr)) -htmlVideoElementSetWidth :: - (HTMLVideoElementClass self) => self -> Word -> IO () -htmlVideoElementSetWidth self val - = {# call webkit_dom_html_video_element_set_width #} - (toHTMLVideoElement self) - (fromIntegral val) +webkitSetPresentationMode :: + (MonadIO m, HTMLVideoElementClass self) => + self -> VideoPresentationMode -> m () +webkitSetPresentationMode self mode + = liftIO + (withUTFString (enumToString mode) $ + \ modePtr -> + {# call webkit_dom_html_video_element_webkit_set_presentation_mode + #} + (toHTMLVideoElement self) + modePtr) +#endif -htmlVideoElementGetWidth :: - (HTMLVideoElementClass self) => self -> IO Word -htmlVideoElementGetWidth self - = fromIntegral <$> - ({# call webkit_dom_html_video_element_get_width #} - (toHTMLVideoElement self)) +setWidth :: + (MonadIO m, HTMLVideoElementClass self) => self -> Word -> m () +setWidth self val + = liftIO + ({# call webkit_dom_html_video_element_set_width #} + (toHTMLVideoElement self) + (fromIntegral val)) -htmlVideoElementSetHeight :: - (HTMLVideoElementClass self) => self -> Word -> IO () -htmlVideoElementSetHeight self val - = {# call webkit_dom_html_video_element_set_height #} - (toHTMLVideoElement self) - (fromIntegral val) +getWidth :: + (MonadIO m, HTMLVideoElementClass self) => self -> m Word +getWidth self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_video_element_get_width #} + (toHTMLVideoElement self))) -htmlVideoElementGetHeight :: - (HTMLVideoElementClass self) => self -> IO Word -htmlVideoElementGetHeight self - = fromIntegral <$> - ({# call webkit_dom_html_video_element_get_height #} - (toHTMLVideoElement self)) +setHeight :: + (MonadIO m, HTMLVideoElementClass self) => self -> Word -> m () +setHeight self val + = liftIO + ({# call webkit_dom_html_video_element_set_height #} + (toHTMLVideoElement self) + (fromIntegral val)) -htmlVideoElementGetVideoWidth :: - (HTMLVideoElementClass self) => self -> IO Word -htmlVideoElementGetVideoWidth self - = fromIntegral <$> - ({# call webkit_dom_html_video_element_get_video_width #} - (toHTMLVideoElement self)) +getHeight :: + (MonadIO m, HTMLVideoElementClass self) => self -> m Word +getHeight self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_video_element_get_height #} + (toHTMLVideoElement self))) -htmlVideoElementGetVideoHeight :: - (HTMLVideoElementClass self) => self -> IO Word -htmlVideoElementGetVideoHeight self - = fromIntegral <$> - ({# call webkit_dom_html_video_element_get_video_height #} - (toHTMLVideoElement self)) +getVideoWidth :: + (MonadIO m, HTMLVideoElementClass self) => self -> m Word +getVideoWidth self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_video_element_get_video_width #} + (toHTMLVideoElement self))) -htmlVideoElementSetPoster :: - (HTMLVideoElementClass self) => self -> String -> IO () -htmlVideoElementSetPoster self val - = withUTFString val $ - \ valPtr -> - {# call webkit_dom_html_video_element_set_poster #} - (toHTMLVideoElement self) - valPtr +getVideoHeight :: + (MonadIO m, HTMLVideoElementClass self) => self -> m Word +getVideoHeight self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_video_element_get_video_height #} + (toHTMLVideoElement self))) -htmlVideoElementGetPoster :: - (HTMLVideoElementClass self) => self -> IO String -htmlVideoElementGetPoster self - = ({# call webkit_dom_html_video_element_get_poster #} - (toHTMLVideoElement self)) - >>= - readUTFString +setPoster :: + (MonadIO m, HTMLVideoElementClass self, GlibString string) => + self -> string -> m () +setPoster self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_video_element_set_poster #} + (toHTMLVideoElement self) + valPtr) -htmlVideoElementGetWebkitSupportsFullscreen :: - (HTMLVideoElementClass self) => self -> IO Bool -htmlVideoElementGetWebkitSupportsFullscreen self - = toBool <$> - ({# call - webkit_dom_html_video_element_get_webkit_supports_fullscreen - #} - (toHTMLVideoElement self)) +getPoster :: + (MonadIO m, HTMLVideoElementClass self, GlibString string) => + self -> m string +getPoster self + = liftIO + (({# call webkit_dom_html_video_element_get_poster #} + (toHTMLVideoElement self)) + >>= + readUTFString) -htmlVideoElementGetWebkitDisplayingFullscreen :: - (HTMLVideoElementClass self) => self -> IO Bool -htmlVideoElementGetWebkitDisplayingFullscreen self - = toBool <$> - ({# call - webkit_dom_html_video_element_get_webkit_displaying_fullscreen - #} - (toHTMLVideoElement self)) +getWebkitSupportsFullscreen :: + (MonadIO m, HTMLVideoElementClass self) => self -> m Bool +getWebkitSupportsFullscreen self + = liftIO + (toBool <$> + ({# call + webkit_dom_html_video_element_get_webkit_supports_fullscreen + #} + (toHTMLVideoElement self))) -htmlVideoElementGetWebkitDecodedFrameCount :: - (HTMLVideoElementClass self) => self -> IO Word -htmlVideoElementGetWebkitDecodedFrameCount self - = fromIntegral <$> +getWebkitDisplayingFullscreen :: + (MonadIO m, HTMLVideoElementClass self) => self -> m Bool +getWebkitDisplayingFullscreen self + = liftIO + (toBool <$> + ({# call + webkit_dom_html_video_element_get_webkit_displaying_fullscreen + #} + (toHTMLVideoElement self))) + +#if WEBKIT_CHECK_VERSION(2,4,0) +setWebkitWirelessVideoPlaybackDisabled :: + (MonadIO m, HTMLVideoElementClass self) => + self -> Bool -> m () +setWebkitWirelessVideoPlaybackDisabled self val + = liftIO ({# call - webkit_dom_html_video_element_get_webkit_decoded_frame_count + webkit_dom_html_video_element_set_webkit_wireless_video_playback_disabled #} - (toHTMLVideoElement self)) + (toHTMLVideoElement self) + (fromBool val)) -htmlVideoElementGetWebkitDroppedFrameCount :: - (HTMLVideoElementClass self) => self -> IO Word -htmlVideoElementGetWebkitDroppedFrameCount self - = fromIntegral <$> - ({# call - webkit_dom_html_video_element_get_webkit_dropped_frame_count - #} - (toHTMLVideoElement self)) +getWebkitWirelessVideoPlaybackDisabled :: + (MonadIO m, HTMLVideoElementClass self) => self -> m Bool +getWebkitWirelessVideoPlaybackDisabled self + = liftIO + (toBool <$> + ({# call + webkit_dom_html_video_element_get_webkit_wireless_video_playback_disabled + #} + (toHTMLVideoElement self))) +#endif + +getWebkitDecodedFrameCount :: + (MonadIO m, HTMLVideoElementClass self) => self -> m Word +getWebkitDecodedFrameCount self + = liftIO + (fromIntegral <$> + ({# call + webkit_dom_html_video_element_get_webkit_decoded_frame_count + #} + (toHTMLVideoElement self))) + +getWebkitDroppedFrameCount :: + (MonadIO m, HTMLVideoElementClass self) => self -> m Word +getWebkitDroppedFrameCount self + = liftIO + (fromIntegral <$> + ({# call + webkit_dom_html_video_element_get_webkit_dropped_frame_count + #} + (toHTMLVideoElement self))) + +#if WEBKIT_CHECK_VERSION(99,0,0) +getWebkitPresentationMode :: + (MonadIO m, HTMLVideoElementClass self) => + self -> m VideoPresentationMode +getWebkitPresentationMode self + = liftIO + (stringToEnum <$> + (({# call + webkit_dom_html_video_element_get_webkit_presentation_mode + #} + (toHTMLVideoElement self)) + >>= + readUTFString)) +#endif + +webKitPresentationModeChanged :: + (HTMLVideoElementClass self) => EventName self Event +webKitPresentationModeChanged + = EventName "webkitpresentationmodechanged" diff --git a/Graphics/UI/Gtk/WebKit/DOM/History.chs b/Graphics/UI/Gtk/WebKit/DOM/History.chs --- a/Graphics/UI/Gtk/WebKit/DOM/History.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/History.chs @@ -1,15 +1,28 @@ -module Graphics.UI.Gtk.WebKit.DOM.History - (historyGetLength, History, HistoryClass, castToHistory, - gTypeHistory, toHistory) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.History( +getLength, +History, +castToHistory, +gTypeHistory, +HistoryClass, +toHistory, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -historyGetLength :: (HistoryClass self) => self -> IO Word -historyGetLength self - = fromIntegral <$> - ({# call webkit_dom_history_get_length #} (toHistory self)) +getLength :: (MonadIO m, HistoryClass self) => self -> m Word +getLength self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_history_get_length #} (toHistory self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/KeyboardEvent.chs b/Graphics/UI/Gtk/WebKit/DOM/KeyboardEvent.chs --- a/Graphics/UI/Gtk/WebKit/DOM/KeyboardEvent.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/KeyboardEvent.chs @@ -1,116 +1,162 @@ -module Graphics.UI.Gtk.WebKit.DOM.KeyboardEvent - ( +module Graphics.UI.Gtk.WebKit.DOM.KeyboardEvent( #if WEBKIT_CHECK_VERSION(2,2,2) - keyboardEventGetModifierState, keyboardEventInitKeyboardEvent, - cKEY_LOCATION_STANDARD, cKEY_LOCATION_LEFT, cKEY_LOCATION_RIGHT, - cKEY_LOCATION_NUMPAD, keyboardEventGetKeyIdentifier, - keyboardEventGetKeyLocation, keyboardEventGetCtrlKey, - keyboardEventGetShiftKey, keyboardEventGetAltKey, - keyboardEventGetMetaKey, keyboardEventGetAltGraphKey, - KeyboardEvent, KeyboardEventClass, castToKeyboardEvent, - gTypeKeyboardEvent, toKeyboardEvent +getModifierState, +initKeyboardEvent, +pattern KEY_LOCATION_STANDARD, +pattern KEY_LOCATION_LEFT, +pattern KEY_LOCATION_RIGHT, +pattern KEY_LOCATION_NUMPAD, +getKeyIdentifier, +getKeyLocation, +getCtrlKey, +getShiftKey, +getAltKey, +getMetaKey, +getAltGraphKey, +#if WEBKIT_CHECK_VERSION(99,0,0) +getKeyCode, +getCharCode, #endif - ) - where - +KeyboardEvent, +castToKeyboardEvent, +gTypeKeyboardEvent, +KeyboardEventClass, +toKeyboardEvent, +#endif +) where #if WEBKIT_CHECK_VERSION(2,2,2) -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -keyboardEventGetModifierState :: - (KeyboardEventClass self) => self -> String -> IO Bool -keyboardEventGetModifierState self keyIdentifierArg - = toBool <$> - (withUTFString keyIdentifierArg $ - \ keyIdentifierArgPtr -> - {# call webkit_dom_keyboard_event_get_modifier_state #} - (toKeyboardEvent self) - keyIdentifierArgPtr) +getModifierState :: + (MonadIO m, KeyboardEventClass self, GlibString string) => + self -> string -> m Bool +getModifierState self keyIdentifierArg + = liftIO + (toBool <$> + (withUTFString keyIdentifierArg $ + \ keyIdentifierArgPtr -> + {# call webkit_dom_keyboard_event_get_modifier_state #} + (toKeyboardEvent self) + keyIdentifierArgPtr)) -keyboardEventInitKeyboardEvent :: - (KeyboardEventClass self, DOMWindowClass view) => - self -> - String -> - Bool -> - Bool -> - Maybe view -> - String -> - Word -> Bool -> Bool -> Bool -> Bool -> Bool -> IO () -keyboardEventInitKeyboardEvent self type' canBubble cancelable view +initKeyboardEvent :: + (MonadIO m, KeyboardEventClass self, WindowClass view, + GlibString string) => + self -> + string -> + Bool -> + Bool -> + Maybe view -> + string -> Word -> Bool -> Bool -> Bool -> Bool -> Bool -> m () +initKeyboardEvent self type' canBubble cancelable view keyIdentifier location ctrlKey altKey shiftKey metaKey altGraphKey - = withUTFString keyIdentifier $ - \ keyIdentifierPtr -> - withUTFString type' $ - \ typePtr -> - {# call webkit_dom_keyboard_event_init_keyboard_event #} - (toKeyboardEvent self) - typePtr - (fromBool canBubble) - (fromBool cancelable) - (maybe (DOMWindow nullForeignPtr) toDOMWindow view) - keyIdentifierPtr - (fromIntegral location) - (fromBool ctrlKey) - (fromBool altKey) - (fromBool shiftKey) - (fromBool metaKey) - (fromBool altGraphKey) -cKEY_LOCATION_STANDARD = 0 -cKEY_LOCATION_LEFT = 1 -cKEY_LOCATION_RIGHT = 2 -cKEY_LOCATION_NUMPAD = 3 + = liftIO + (withUTFString keyIdentifier $ + \ keyIdentifierPtr -> + withUTFString type' $ + \ typePtr -> + {# call webkit_dom_keyboard_event_init_keyboard_event #} + (toKeyboardEvent self) + typePtr + (fromBool canBubble) + (fromBool cancelable) + (maybe (Window nullForeignPtr) toWindow view) + keyIdentifierPtr + (fromIntegral location) + (fromBool ctrlKey) + (fromBool altKey) + (fromBool shiftKey) + (fromBool metaKey) + (fromBool altGraphKey)) +pattern KEY_LOCATION_STANDARD = 0 +pattern KEY_LOCATION_LEFT = 1 +pattern KEY_LOCATION_RIGHT = 2 +pattern KEY_LOCATION_NUMPAD = 3 -keyboardEventGetKeyIdentifier :: - (KeyboardEventClass self) => self -> IO String -keyboardEventGetKeyIdentifier self - = ({# call webkit_dom_keyboard_event_get_key_identifier #} - (toKeyboardEvent self)) - >>= - readUTFString +getKeyIdentifier :: + (MonadIO m, KeyboardEventClass self, GlibString string) => + self -> m string +getKeyIdentifier self + = liftIO + (({# call webkit_dom_keyboard_event_get_key_identifier #} + (toKeyboardEvent self)) + >>= + readUTFString) -keyboardEventGetKeyLocation :: - (KeyboardEventClass self) => self -> IO Word -keyboardEventGetKeyLocation self - = fromIntegral <$> - ({# call webkit_dom_keyboard_event_get_key_location #} - (toKeyboardEvent self)) +getKeyLocation :: + (MonadIO m, KeyboardEventClass self) => self -> m Word +getKeyLocation self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_keyboard_event_get_key_location #} + (toKeyboardEvent self))) -keyboardEventGetCtrlKey :: - (KeyboardEventClass self) => self -> IO Bool -keyboardEventGetCtrlKey self - = toBool <$> - ({# call webkit_dom_keyboard_event_get_ctrl_key #} - (toKeyboardEvent self)) +getCtrlKey :: + (MonadIO m, KeyboardEventClass self) => self -> m Bool +getCtrlKey self + = liftIO + (toBool <$> + ({# call webkit_dom_keyboard_event_get_ctrl_key #} + (toKeyboardEvent self))) -keyboardEventGetShiftKey :: - (KeyboardEventClass self) => self -> IO Bool -keyboardEventGetShiftKey self - = toBool <$> - ({# call webkit_dom_keyboard_event_get_shift_key #} - (toKeyboardEvent self)) +getShiftKey :: + (MonadIO m, KeyboardEventClass self) => self -> m Bool +getShiftKey self + = liftIO + (toBool <$> + ({# call webkit_dom_keyboard_event_get_shift_key #} + (toKeyboardEvent self))) -keyboardEventGetAltKey :: - (KeyboardEventClass self) => self -> IO Bool -keyboardEventGetAltKey self - = toBool <$> - ({# call webkit_dom_keyboard_event_get_alt_key #} - (toKeyboardEvent self)) +getAltKey :: (MonadIO m, KeyboardEventClass self) => self -> m Bool +getAltKey self + = liftIO + (toBool <$> + ({# call webkit_dom_keyboard_event_get_alt_key #} + (toKeyboardEvent self))) -keyboardEventGetMetaKey :: - (KeyboardEventClass self) => self -> IO Bool -keyboardEventGetMetaKey self - = toBool <$> - ({# call webkit_dom_keyboard_event_get_meta_key #} - (toKeyboardEvent self)) +getMetaKey :: + (MonadIO m, KeyboardEventClass self) => self -> m Bool +getMetaKey self + = liftIO + (toBool <$> + ({# call webkit_dom_keyboard_event_get_meta_key #} + (toKeyboardEvent self))) -keyboardEventGetAltGraphKey :: - (KeyboardEventClass self) => self -> IO Bool -keyboardEventGetAltGraphKey self - = toBool <$> - ({# call webkit_dom_keyboard_event_get_alt_graph_key #} - (toKeyboardEvent self)) +getAltGraphKey :: + (MonadIO m, KeyboardEventClass self) => self -> m Bool +getAltGraphKey self + = liftIO + (toBool <$> + ({# call webkit_dom_keyboard_event_get_alt_graph_key #} + (toKeyboardEvent self))) + +#if WEBKIT_CHECK_VERSION(99,0,0) +getKeyCode :: (MonadIO m, KeyboardEventClass self) => self -> m Int +getKeyCode self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_keyboard_event_get_key_code #} + (toKeyboardEvent self))) + +getCharCode :: + (MonadIO m, KeyboardEventClass self) => self -> m Int +getCharCode self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_keyboard_event_get_char_code #} + (toKeyboardEvent self))) +#endif #endif diff --git a/Graphics/UI/Gtk/WebKit/DOM/Location.chs b/Graphics/UI/Gtk/WebKit/DOM/Location.chs --- a/Graphics/UI/Gtk/WebKit/DOM/Location.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/Location.chs @@ -1,26 +1,43 @@ -module Graphics.UI.Gtk.WebKit.DOM.Location - (locationGetOrigin, -#if WEBKIT_CHECK_VERSION(1,10,0) - locationGetAncestorOrigins, +module Graphics.UI.Gtk.WebKit.DOM.Location( +getOrigin, +#if WEBKIT_CHECK_VERSION(2,2,2) +getAncestorOrigins, #endif - Location, LocationClass, castToLocation, gTypeLocation, toLocation) where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +Location, +castToLocation, +gTypeLocation, +LocationClass, +toLocation, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM - -locationGetOrigin :: (LocationClass self) => self -> IO String -locationGetOrigin self - = ({# call webkit_dom_location_get_origin #} (toLocation self)) >>= - readUTFString +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -#if WEBKIT_CHECK_VERSION(1,10,0) -locationGetAncestorOrigins :: - (LocationClass self) => self -> IO (Maybe DOMStringList) -locationGetAncestorOrigins self - = maybeNull (makeNewGObject mkDOMStringList) - ({# call webkit_dom_location_get_ancestor_origins #} - (toLocation self)) +getOrigin :: + (MonadIO m, LocationClass self, GlibString string) => + self -> m string +getOrigin self + = liftIO + (({# call webkit_dom_location_get_origin #} (toLocation self)) >>= + readUTFString) + +#if WEBKIT_CHECK_VERSION(2,2,2) +getAncestorOrigins :: + (MonadIO m, LocationClass self) => self -> m (Maybe DOMStringList) +getAncestorOrigins self + = liftIO + (maybeNull (makeNewGObject mkDOMStringList) + ({# call webkit_dom_location_get_ancestor_origins #} + (toLocation self))) #endif diff --git a/Graphics/UI/Gtk/WebKit/DOM/MediaError.chs b/Graphics/UI/Gtk/WebKit/DOM/MediaError.chs --- a/Graphics/UI/Gtk/WebKit/DOM/MediaError.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/MediaError.chs @@ -1,20 +1,38 @@ -module Graphics.UI.Gtk.WebKit.DOM.MediaError - (cMEDIA_ERR_ABORTED, cMEDIA_ERR_NETWORK, cMEDIA_ERR_DECODE, - cMEDIA_ERR_SRC_NOT_SUPPORTED, mediaErrorGetCode, MediaError, - MediaErrorClass, castToMediaError, gTypeMediaError, toMediaError) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.MediaError( +pattern MEDIA_ERR_ABORTED, +pattern MEDIA_ERR_NETWORK, +pattern MEDIA_ERR_DECODE, +pattern MEDIA_ERR_SRC_NOT_SUPPORTED, +pattern MEDIA_ERR_ENCRYPTED, +getCode, +MediaError, +castToMediaError, +gTypeMediaError, +MediaErrorClass, +toMediaError, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM -cMEDIA_ERR_ABORTED = 1 -cMEDIA_ERR_NETWORK = 2 -cMEDIA_ERR_DECODE = 3 -cMEDIA_ERR_SRC_NOT_SUPPORTED = 4 +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + +pattern MEDIA_ERR_ABORTED = 1 +pattern MEDIA_ERR_NETWORK = 2 +pattern MEDIA_ERR_DECODE = 3 +pattern MEDIA_ERR_SRC_NOT_SUPPORTED = 4 +pattern MEDIA_ERR_ENCRYPTED = 5 -mediaErrorGetCode :: (MediaErrorClass self) => self -> IO Word -mediaErrorGetCode self - = fromIntegral <$> - ({# call webkit_dom_media_error_get_code #} (toMediaError self)) +getCode :: (MonadIO m, MediaErrorClass self) => self -> m Word +getCode self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_media_error_get_code #} (toMediaError self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/MediaList.chs b/Graphics/UI/Gtk/WebKit/DOM/MediaList.chs --- a/Graphics/UI/Gtk/WebKit/DOM/MediaList.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/MediaList.chs @@ -1,64 +1,92 @@ -module Graphics.UI.Gtk.WebKit.DOM.MediaList - (mediaListItem, mediaListDeleteMedium, mediaListAppendMedium, - mediaListSetMediaText, mediaListGetMediaText, mediaListGetLength, - MediaList, MediaListClass, castToMediaList, gTypeMediaList, - toMediaList) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.MediaList( +item, +deleteMedium, +appendMedium, +setMediaText, +getMediaText, +getLength, +MediaList, +castToMediaList, +gTypeMediaList, +MediaListClass, +toMediaList, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -mediaListItem :: (MediaListClass self) => self -> Word -> IO String -mediaListItem self index - = ({# call webkit_dom_media_list_item #} (toMediaList self) - (fromIntegral index)) - >>= - readUTFString +item :: + (MonadIO m, MediaListClass self, GlibString string) => + self -> Word -> m (Maybe string) +item self index + = liftIO + (({# call webkit_dom_media_list_item #} (toMediaList self) + (fromIntegral index)) + >>= + maybePeek readUTFString) -mediaListDeleteMedium :: - (MediaListClass self) => self -> String -> IO () -mediaListDeleteMedium self oldMedium - = propagateGError $ - \ errorPtr_ -> - withUTFString oldMedium $ - \ oldMediumPtr -> - {# call webkit_dom_media_list_delete_medium #} (toMediaList self) - oldMediumPtr - errorPtr_ +deleteMedium :: + (MonadIO m, MediaListClass self, GlibString string) => + self -> string -> m () +deleteMedium self oldMedium + = liftIO + (propagateGError $ + \ errorPtr_ -> + withUTFString oldMedium $ + \ oldMediumPtr -> + {# call webkit_dom_media_list_delete_medium #} (toMediaList self) + oldMediumPtr + errorPtr_) -mediaListAppendMedium :: - (MediaListClass self) => self -> String -> IO () -mediaListAppendMedium self newMedium - = propagateGError $ - \ errorPtr_ -> - withUTFString newMedium $ - \ newMediumPtr -> - {# call webkit_dom_media_list_append_medium #} (toMediaList self) - newMediumPtr - errorPtr_ +appendMedium :: + (MonadIO m, MediaListClass self, GlibString string) => + self -> string -> m () +appendMedium self newMedium + = liftIO + (propagateGError $ + \ errorPtr_ -> + withUTFString newMedium $ + \ newMediumPtr -> + {# call webkit_dom_media_list_append_medium #} (toMediaList self) + newMediumPtr + errorPtr_) -mediaListSetMediaText :: - (MediaListClass self) => self -> String -> IO () -mediaListSetMediaText self val - = propagateGError $ - \ errorPtr_ -> - withUTFString val $ - \ valPtr -> - {# call webkit_dom_media_list_set_media_text #} (toMediaList self) - valPtr - errorPtr_ +setMediaText :: + (MonadIO m, MediaListClass self, GlibString string) => + self -> (Maybe string) -> m () +setMediaText self val + = liftIO + (propagateGError $ + \ errorPtr_ -> + maybeWith withUTFString val $ + \ valPtr -> + {# call webkit_dom_media_list_set_media_text #} (toMediaList self) + valPtr + errorPtr_) -mediaListGetMediaText :: (MediaListClass self) => self -> IO String -mediaListGetMediaText self - = ({# call webkit_dom_media_list_get_media_text #} - (toMediaList self)) - >>= - readUTFString +getMediaText :: + (MonadIO m, MediaListClass self, GlibString string) => + self -> m (Maybe string) +getMediaText self + = liftIO + (({# call webkit_dom_media_list_get_media_text #} + (toMediaList self)) + >>= + maybePeek readUTFString) -mediaListGetLength :: (MediaListClass self) => self -> IO Word -mediaListGetLength self - = fromIntegral <$> - ({# call webkit_dom_media_list_get_length #} (toMediaList self)) +getLength :: (MonadIO m, MediaListClass self) => self -> m Word +getLength self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_media_list_get_length #} (toMediaList self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/MediaQueryList.chs b/Graphics/UI/Gtk/WebKit/DOM/MediaQueryList.chs --- a/Graphics/UI/Gtk/WebKit/DOM/MediaQueryList.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/MediaQueryList.chs @@ -1,26 +1,41 @@ -module Graphics.UI.Gtk.WebKit.DOM.MediaQueryList - (mediaQueryListGetMedia, mediaQueryListGetMatches, MediaQueryList, - MediaQueryListClass, castToMediaQueryList, gTypeMediaQueryList, - toMediaQueryList) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.MediaQueryList( +getMedia, +getMatches, +MediaQueryList, +castToMediaQueryList, +gTypeMediaQueryList, +MediaQueryListClass, +toMediaQueryList, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -mediaQueryListGetMedia :: - (MediaQueryListClass self) => self -> IO String -mediaQueryListGetMedia self - = ({# call webkit_dom_media_query_list_get_media #} - (toMediaQueryList self)) - >>= - readUTFString +getMedia :: + (MonadIO m, MediaQueryListClass self, GlibString string) => + self -> m string +getMedia self + = liftIO + (({# call webkit_dom_media_query_list_get_media #} + (toMediaQueryList self)) + >>= + readUTFString) -mediaQueryListGetMatches :: - (MediaQueryListClass self) => self -> IO Bool -mediaQueryListGetMatches self - = toBool <$> - ({# call webkit_dom_media_query_list_get_matches #} - (toMediaQueryList self)) +getMatches :: + (MonadIO m, MediaQueryListClass self) => self -> m Bool +getMatches self + = liftIO + (toBool <$> + ({# call webkit_dom_media_query_list_get_matches #} + (toMediaQueryList self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/MimeType.chs b/Graphics/UI/Gtk/WebKit/DOM/MimeType.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/MimeType.chs @@ -0,0 +1,52 @@ +module Graphics.UI.Gtk.WebKit.DOM.MimeType( +getSuffixes, +getDescription, +getEnabledPlugin, +MimeType, +castToMimeType, +gTypeMimeType, +MimeTypeClass, +toMimeType, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures +import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + + +getSuffixes :: + (MonadIO m, MimeTypeClass self, GlibString string) => + self -> m string +getSuffixes self + = liftIO + (({# call webkit_dom_dom_mime_type_get_suffixes #} + (toMimeType self)) + >>= + readUTFString) + +getDescription :: + (MonadIO m, MimeTypeClass self, GlibString string) => + self -> m string +getDescription self + = liftIO + (({# call webkit_dom_dom_mime_type_get_description #} + (toMimeType self)) + >>= + readUTFString) + +getEnabledPlugin :: + (MonadIO m, MimeTypeClass self) => self -> m (Maybe Plugin) +getEnabledPlugin self + = liftIO + (maybeNull (makeNewGObject mkPlugin) + ({# call webkit_dom_dom_mime_type_get_enabled_plugin #} + (toMimeType self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/MimeTypeArray.chs b/Graphics/UI/Gtk/WebKit/DOM/MimeTypeArray.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/MimeTypeArray.chs @@ -0,0 +1,53 @@ +module Graphics.UI.Gtk.WebKit.DOM.MimeTypeArray( +item, +namedItem, +getLength, +MimeTypeArray, +castToMimeTypeArray, +gTypeMimeTypeArray, +MimeTypeArrayClass, +toMimeTypeArray, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures +import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + + +item :: + (MonadIO m, MimeTypeArrayClass self) => + self -> Word -> m (Maybe MimeType) +item self index + = liftIO + (maybeNull (makeNewGObject mkMimeType) + ({# call webkit_dom_dom_mime_type_array_item #} + (toMimeTypeArray self) + (fromIntegral index))) + +namedItem :: + (MonadIO m, MimeTypeArrayClass self, GlibString string) => + self -> string -> m (Maybe MimeType) +namedItem self name + = liftIO + (maybeNull (makeNewGObject mkMimeType) + (withUTFString name $ + \ namePtr -> + {# call webkit_dom_dom_mime_type_array_named_item #} + (toMimeTypeArray self) + namePtr)) + +getLength :: (MonadIO m, MimeTypeArrayClass self) => self -> m Word +getLength self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_dom_mime_type_array_get_length #} + (toMimeTypeArray self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/MouseEvent.chs b/Graphics/UI/Gtk/WebKit/DOM/MouseEvent.chs --- a/Graphics/UI/Gtk/WebKit/DOM/MouseEvent.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/MouseEvent.chs @@ -1,165 +1,212 @@ -module Graphics.UI.Gtk.WebKit.DOM.MouseEvent - (mouseEventInitMouseEvent, mouseEventGetScreenX, - mouseEventGetScreenY, mouseEventGetClientX, mouseEventGetClientY, - mouseEventGetCtrlKey, mouseEventGetShiftKey, mouseEventGetAltKey, - mouseEventGetMetaKey, mouseEventGetButton, - mouseEventGetRelatedTarget, mouseEventGetWebkitMovementX, - mouseEventGetWebkitMovementY, mouseEventGetOffsetX, - mouseEventGetOffsetY, mouseEventGetX, mouseEventGetY, - mouseEventGetFromElement, mouseEventGetToElement, MouseEvent, - MouseEventClass, castToMouseEvent, gTypeMouseEvent, toMouseEvent) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.MouseEvent( +initMouseEvent, +getScreenX, +getScreenY, +getClientX, +getClientY, +getCtrlKey, +getShiftKey, +getAltKey, +getMetaKey, +getButton, +getRelatedTarget, +getMovementX, +getMovementY, +getOffsetX, +getOffsetY, +getX, +getY, +getFromElement, +getToElement, +MouseEvent, +castToMouseEvent, +gTypeMouseEvent, +MouseEventClass, +toMouseEvent, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -mouseEventInitMouseEvent :: - (MouseEventClass self, DOMWindowClass view, - EventTargetClass relatedTarget) => - self -> - String -> - Bool -> - Bool -> - Maybe view -> - Int -> - Int -> - Int -> - Int -> - Int -> - Bool -> - Bool -> - Bool -> - Bool -> Word -> Maybe relatedTarget -> IO () -mouseEventInitMouseEvent self type' canBubble cancelable view - detail screenX screenY clientX clientY ctrlKey altKey shiftKey - metaKey button relatedTarget - = withUTFString type' $ - \ typePtr -> - {# call webkit_dom_mouse_event_init_mouse_event #} - (toMouseEvent self) - typePtr - (fromBool canBubble) - (fromBool cancelable) - (maybe (DOMWindow nullForeignPtr) toDOMWindow view) - (fromIntegral detail) - (fromIntegral screenX) - (fromIntegral screenY) - (fromIntegral clientX) - (fromIntegral clientY) - (fromBool ctrlKey) - (fromBool altKey) - (fromBool shiftKey) - (fromBool metaKey) - (fromIntegral button) - (maybe (EventTarget nullForeignPtr) toEventTarget relatedTarget) +initMouseEvent :: + (MonadIO m, MouseEventClass self, WindowClass view, + EventTargetClass relatedTarget, GlibString string) => + self -> + string -> + Bool -> + Bool -> + Maybe view -> + Int -> + Int -> + Int -> + Int -> + Int -> + Bool -> + Bool -> Bool -> Bool -> Word -> Maybe relatedTarget -> m () +initMouseEvent self type' canBubble cancelable view detail screenX + screenY clientX clientY ctrlKey altKey shiftKey metaKey button + relatedTarget + = liftIO + (withUTFString type' $ + \ typePtr -> + {# call webkit_dom_mouse_event_init_mouse_event #} + (toMouseEvent self) + typePtr + (fromBool canBubble) + (fromBool cancelable) + (maybe (Window nullForeignPtr) toWindow view) + (fromIntegral detail) + (fromIntegral screenX) + (fromIntegral screenY) + (fromIntegral clientX) + (fromIntegral clientY) + (fromBool ctrlKey) + (fromBool altKey) + (fromBool shiftKey) + (fromBool metaKey) + (fromIntegral button) + (maybe (EventTarget nullForeignPtr) toEventTarget relatedTarget)) -mouseEventGetScreenX :: (MouseEventClass self) => self -> IO Int -mouseEventGetScreenX self - = fromIntegral <$> - ({# call webkit_dom_mouse_event_get_screen_x #} - (toMouseEvent self)) +getScreenX :: (MonadIO m, MouseEventClass self) => self -> m Int +getScreenX self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_mouse_event_get_screen_x #} + (toMouseEvent self))) -mouseEventGetScreenY :: (MouseEventClass self) => self -> IO Int -mouseEventGetScreenY self - = fromIntegral <$> - ({# call webkit_dom_mouse_event_get_screen_y #} - (toMouseEvent self)) +getScreenY :: (MonadIO m, MouseEventClass self) => self -> m Int +getScreenY self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_mouse_event_get_screen_y #} + (toMouseEvent self))) -mouseEventGetClientX :: (MouseEventClass self) => self -> IO Int -mouseEventGetClientX self - = fromIntegral <$> - ({# call webkit_dom_mouse_event_get_client_x #} - (toMouseEvent self)) +getClientX :: (MonadIO m, MouseEventClass self) => self -> m Int +getClientX self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_mouse_event_get_client_x #} + (toMouseEvent self))) -mouseEventGetClientY :: (MouseEventClass self) => self -> IO Int -mouseEventGetClientY self - = fromIntegral <$> - ({# call webkit_dom_mouse_event_get_client_y #} - (toMouseEvent self)) +getClientY :: (MonadIO m, MouseEventClass self) => self -> m Int +getClientY self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_mouse_event_get_client_y #} + (toMouseEvent self))) -mouseEventGetCtrlKey :: (MouseEventClass self) => self -> IO Bool -mouseEventGetCtrlKey self - = toBool <$> - ({# call webkit_dom_mouse_event_get_ctrl_key #} - (toMouseEvent self)) +getCtrlKey :: (MonadIO m, MouseEventClass self) => self -> m Bool +getCtrlKey self + = liftIO + (toBool <$> + ({# call webkit_dom_mouse_event_get_ctrl_key #} + (toMouseEvent self))) -mouseEventGetShiftKey :: (MouseEventClass self) => self -> IO Bool -mouseEventGetShiftKey self - = toBool <$> - ({# call webkit_dom_mouse_event_get_shift_key #} - (toMouseEvent self)) +getShiftKey :: (MonadIO m, MouseEventClass self) => self -> m Bool +getShiftKey self + = liftIO + (toBool <$> + ({# call webkit_dom_mouse_event_get_shift_key #} + (toMouseEvent self))) -mouseEventGetAltKey :: (MouseEventClass self) => self -> IO Bool -mouseEventGetAltKey self - = toBool <$> - ({# call webkit_dom_mouse_event_get_alt_key #} (toMouseEvent self)) +getAltKey :: (MonadIO m, MouseEventClass self) => self -> m Bool +getAltKey self + = liftIO + (toBool <$> + ({# call webkit_dom_mouse_event_get_alt_key #} + (toMouseEvent self))) -mouseEventGetMetaKey :: (MouseEventClass self) => self -> IO Bool -mouseEventGetMetaKey self - = toBool <$> - ({# call webkit_dom_mouse_event_get_meta_key #} - (toMouseEvent self)) +getMetaKey :: (MonadIO m, MouseEventClass self) => self -> m Bool +getMetaKey self + = liftIO + (toBool <$> + ({# call webkit_dom_mouse_event_get_meta_key #} + (toMouseEvent self))) -mouseEventGetButton :: (MouseEventClass self) => self -> IO Word -mouseEventGetButton self - = fromIntegral <$> - ({# call webkit_dom_mouse_event_get_button #} (toMouseEvent self)) +getButton :: (MonadIO m, MouseEventClass self) => self -> m Word +getButton self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_mouse_event_get_button #} (toMouseEvent self))) -mouseEventGetRelatedTarget :: - (MouseEventClass self) => self -> IO (Maybe EventTarget) -mouseEventGetRelatedTarget self - = maybeNull (makeNewGObject mkEventTarget) - ({# call webkit_dom_mouse_event_get_related_target #} - (toMouseEvent self)) +getRelatedTarget :: + (MonadIO m, MouseEventClass self) => self -> m (Maybe EventTarget) +getRelatedTarget self + = liftIO + (maybeNull (makeNewGObject mkEventTarget) + ({# call webkit_dom_mouse_event_get_related_target #} + (toMouseEvent self))) -mouseEventGetWebkitMovementX :: - (MouseEventClass self) => self -> IO Int -mouseEventGetWebkitMovementX self - = fromIntegral <$> - ({# call webkit_dom_mouse_event_get_webkit_movement_x #} - (toMouseEvent self)) +getMovementX :: (MonadIO m, MouseEventClass self) => self -> m Int +getMovementX self + = liftIO + (fromIntegral <$> +#if WEBKIT_CHECK_VERSION(2,6,0) + ({# call webkit_dom_mouse_event_get_movement_x #} +#else + ({# call webkit_dom_mouse_event_get_webkit_movement_x #} +#endif + (toMouseEvent self))) -mouseEventGetWebkitMovementY :: - (MouseEventClass self) => self -> IO Int -mouseEventGetWebkitMovementY self - = fromIntegral <$> - ({# call webkit_dom_mouse_event_get_webkit_movement_y #} - (toMouseEvent self)) +getMovementY :: (MonadIO m, MouseEventClass self) => self -> m Int +getMovementY self + = liftIO + (fromIntegral <$> +#if WEBKIT_CHECK_VERSION(2,6,0) + ({# call webkit_dom_mouse_event_get_movement_y #} +#else + ({# call webkit_dom_mouse_event_get_webkit_movement_y #} +#endif + (toMouseEvent self))) -mouseEventGetOffsetX :: (MouseEventClass self) => self -> IO Int -mouseEventGetOffsetX self - = fromIntegral <$> - ({# call webkit_dom_mouse_event_get_offset_x #} - (toMouseEvent self)) +getOffsetX :: (MonadIO m, MouseEventClass self) => self -> m Int +getOffsetX self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_mouse_event_get_offset_x #} + (toMouseEvent self))) -mouseEventGetOffsetY :: (MouseEventClass self) => self -> IO Int -mouseEventGetOffsetY self - = fromIntegral <$> - ({# call webkit_dom_mouse_event_get_offset_y #} - (toMouseEvent self)) +getOffsetY :: (MonadIO m, MouseEventClass self) => self -> m Int +getOffsetY self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_mouse_event_get_offset_y #} + (toMouseEvent self))) -mouseEventGetX :: (MouseEventClass self) => self -> IO Int -mouseEventGetX self - = fromIntegral <$> - ({# call webkit_dom_mouse_event_get_x #} (toMouseEvent self)) +getX :: (MonadIO m, MouseEventClass self) => self -> m Int +getX self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_mouse_event_get_x #} (toMouseEvent self))) -mouseEventGetY :: (MouseEventClass self) => self -> IO Int -mouseEventGetY self - = fromIntegral <$> - ({# call webkit_dom_mouse_event_get_y #} (toMouseEvent self)) +getY :: (MonadIO m, MouseEventClass self) => self -> m Int +getY self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_mouse_event_get_y #} (toMouseEvent self))) -mouseEventGetFromElement :: - (MouseEventClass self) => self -> IO (Maybe Node) -mouseEventGetFromElement self - = maybeNull (makeNewGObject mkNode) - ({# call webkit_dom_mouse_event_get_from_element #} - (toMouseEvent self)) +getFromElement :: + (MonadIO m, MouseEventClass self) => self -> m (Maybe Node) +getFromElement self + = liftIO + (maybeNull (makeNewGObject mkNode) + ({# call webkit_dom_mouse_event_get_from_element #} + (toMouseEvent self))) -mouseEventGetToElement :: - (MouseEventClass self) => self -> IO (Maybe Node) -mouseEventGetToElement self - = maybeNull (makeNewGObject mkNode) - ({# call webkit_dom_mouse_event_get_to_element #} - (toMouseEvent self)) +getToElement :: + (MonadIO m, MouseEventClass self) => self -> m (Maybe Node) +getToElement self + = liftIO + (maybeNull (makeNewGObject mkNode) + ({# call webkit_dom_mouse_event_get_to_element #} + (toMouseEvent self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/NamedNodeMap.chs b/Graphics/UI/Gtk/WebKit/DOM/NamedNodeMap.chs --- a/Graphics/UI/Gtk/WebKit/DOM/NamedNodeMap.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/NamedNodeMap.chs @@ -1,106 +1,131 @@ -module Graphics.UI.Gtk.WebKit.DOM.NamedNodeMap - (namedNodeMapGetNamedItem, namedNodeMapSetNamedItem, - namedNodeMapRemoveNamedItem, namedNodeMapItem, - namedNodeMapGetNamedItemNS, namedNodeMapSetNamedItemNS, - namedNodeMapRemoveNamedItemNS, namedNodeMapGetLength, NamedNodeMap, - NamedNodeMapClass, castToNamedNodeMap, gTypeNamedNodeMap, - toNamedNodeMap) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.NamedNodeMap( +getNamedItem, +setNamedItem, +removeNamedItem, +item, +getNamedItemNS, +setNamedItemNS, +removeNamedItemNS, +getLength, +NamedNodeMap, +castToNamedNodeMap, +gTypeNamedNodeMap, +NamedNodeMapClass, +toNamedNodeMap, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -namedNodeMapGetNamedItem :: - (NamedNodeMapClass self) => self -> String -> IO (Maybe Node) -namedNodeMapGetNamedItem self name - = maybeNull (makeNewGObject mkNode) - (withUTFString name $ - \ namePtr -> - {# call webkit_dom_named_node_map_get_named_item #} - (toNamedNodeMap self) - namePtr) +getNamedItem :: + (MonadIO m, NamedNodeMapClass self, GlibString string) => + self -> string -> m (Maybe Node) +getNamedItem self name + = liftIO + (maybeNull (makeNewGObject mkNode) + (withUTFString name $ + \ namePtr -> + {# call webkit_dom_named_node_map_get_named_item #} + (toNamedNodeMap self) + namePtr)) -namedNodeMapSetNamedItem :: - (NamedNodeMapClass self, NodeClass node) => - self -> Maybe node -> IO (Maybe Node) -namedNodeMapSetNamedItem self node - = maybeNull (makeNewGObject mkNode) - (propagateGError $ - \ errorPtr_ -> - {# call webkit_dom_named_node_map_set_named_item #} - (toNamedNodeMap self) - (maybe (Node nullForeignPtr) toNode node) - errorPtr_) +setNamedItem :: + (MonadIO m, NamedNodeMapClass self, NodeClass node) => + self -> Maybe node -> m (Maybe Node) +setNamedItem self node + = liftIO + (maybeNull (makeNewGObject mkNode) + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_named_node_map_set_named_item #} + (toNamedNodeMap self) + (maybe (Node nullForeignPtr) toNode node) + errorPtr_)) -namedNodeMapRemoveNamedItem :: - (NamedNodeMapClass self) => self -> String -> IO (Maybe Node) -namedNodeMapRemoveNamedItem self name - = maybeNull (makeNewGObject mkNode) - (propagateGError $ - \ errorPtr_ -> - withUTFString name $ - \ namePtr -> - {# call webkit_dom_named_node_map_remove_named_item #} - (toNamedNodeMap self) - namePtr - errorPtr_) +removeNamedItem :: + (MonadIO m, NamedNodeMapClass self, GlibString string) => + self -> string -> m (Maybe Node) +removeNamedItem self name + = liftIO + (maybeNull (makeNewGObject mkNode) + (propagateGError $ + \ errorPtr_ -> + withUTFString name $ + \ namePtr -> + {# call webkit_dom_named_node_map_remove_named_item #} + (toNamedNodeMap self) + namePtr + errorPtr_)) -namedNodeMapItem :: - (NamedNodeMapClass self) => self -> Word -> IO (Maybe Node) -namedNodeMapItem self index - = maybeNull (makeNewGObject mkNode) - ({# call webkit_dom_named_node_map_item #} (toNamedNodeMap self) - (fromIntegral index)) +item :: + (MonadIO m, NamedNodeMapClass self) => + self -> Word -> m (Maybe Node) +item self index + = liftIO + (maybeNull (makeNewGObject mkNode) + ({# call webkit_dom_named_node_map_item #} (toNamedNodeMap self) + (fromIntegral index))) -namedNodeMapGetNamedItemNS :: - (NamedNodeMapClass self) => - self -> String -> String -> IO (Maybe Node) -namedNodeMapGetNamedItemNS self namespaceURI localName - = maybeNull (makeNewGObject mkNode) - (withUTFString localName $ - \ localNamePtr -> - withUTFString namespaceURI $ - \ namespaceURIPtr -> - {# call webkit_dom_named_node_map_get_named_item_ns #} - (toNamedNodeMap self) - namespaceURIPtr - localNamePtr) +getNamedItemNS :: + (MonadIO m, NamedNodeMapClass self, GlibString string) => + self -> (Maybe string) -> string -> m (Maybe Node) +getNamedItemNS self namespaceURI localName + = liftIO + (maybeNull (makeNewGObject mkNode) + (withUTFString localName $ + \ localNamePtr -> + maybeWith withUTFString namespaceURI $ + \ namespaceURIPtr -> + {# call webkit_dom_named_node_map_get_named_item_ns #} + (toNamedNodeMap self) + namespaceURIPtr + localNamePtr)) -namedNodeMapSetNamedItemNS :: - (NamedNodeMapClass self, NodeClass node) => - self -> Maybe node -> IO (Maybe Node) -namedNodeMapSetNamedItemNS self node - = maybeNull (makeNewGObject mkNode) - (propagateGError $ - \ errorPtr_ -> - {# call webkit_dom_named_node_map_set_named_item_ns #} - (toNamedNodeMap self) - (maybe (Node nullForeignPtr) toNode node) - errorPtr_) +setNamedItemNS :: + (MonadIO m, NamedNodeMapClass self, NodeClass node) => + self -> Maybe node -> m (Maybe Node) +setNamedItemNS self node + = liftIO + (maybeNull (makeNewGObject mkNode) + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_named_node_map_set_named_item_ns #} + (toNamedNodeMap self) + (maybe (Node nullForeignPtr) toNode node) + errorPtr_)) -namedNodeMapRemoveNamedItemNS :: - (NamedNodeMapClass self) => - self -> String -> String -> IO (Maybe Node) -namedNodeMapRemoveNamedItemNS self namespaceURI localName - = maybeNull (makeNewGObject mkNode) - (propagateGError $ - \ errorPtr_ -> - withUTFString localName $ - \ localNamePtr -> - withUTFString namespaceURI $ - \ namespaceURIPtr -> - {# call webkit_dom_named_node_map_remove_named_item_ns #} - (toNamedNodeMap self) - namespaceURIPtr - localNamePtr - errorPtr_) +removeNamedItemNS :: + (MonadIO m, NamedNodeMapClass self, GlibString string) => + self -> (Maybe string) -> string -> m (Maybe Node) +removeNamedItemNS self namespaceURI localName + = liftIO + (maybeNull (makeNewGObject mkNode) + (propagateGError $ + \ errorPtr_ -> + withUTFString localName $ + \ localNamePtr -> + maybeWith withUTFString namespaceURI $ + \ namespaceURIPtr -> + {# call webkit_dom_named_node_map_remove_named_item_ns #} + (toNamedNodeMap self) + namespaceURIPtr + localNamePtr + errorPtr_)) -namedNodeMapGetLength :: - (NamedNodeMapClass self) => self -> IO Word -namedNodeMapGetLength self - = fromIntegral <$> - ({# call webkit_dom_named_node_map_get_length #} - (toNamedNodeMap self)) +getLength :: (MonadIO m, NamedNodeMapClass self) => self -> m Word +getLength self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_named_node_map_get_length #} + (toNamedNodeMap self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/Navigator.chs b/Graphics/UI/Gtk/WebKit/DOM/Navigator.chs --- a/Graphics/UI/Gtk/WebKit/DOM/Navigator.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/Navigator.chs @@ -1,119 +1,282 @@ -module Graphics.UI.Gtk.WebKit.DOM.Navigator - (navigatorJavaEnabled, navigatorGetStorageUpdates, - navigatorGetAppCodeName, navigatorGetAppName, - navigatorGetAppVersion, navigatorGetLanguage, - navigatorGetUserAgent, navigatorGetPlatform, navigatorGetPlugins, - navigatorGetMimeTypes, navigatorGetProduct, navigatorGetProductSub, - navigatorGetVendor, navigatorGetVendorSub, - navigatorGetCookieEnabled, navigatorGetOnLine, Navigator, - NavigatorClass, castToNavigator, gTypeNavigator, toNavigator) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.Navigator( +#if WEBKIT_CHECK_VERSION(2,2,2) +registerProtocolHandler, +isProtocolHandlerRegistered, +unregisterProtocolHandler, +#endif +javaEnabled, +getStorageUpdates, +#if WEBKIT_CHECK_VERSION(2,2,2) +getWebkitBattery, +#endif +getGeolocation, +#if WEBKIT_CHECK_VERSION(2,2,2) +getWebkitTemporaryStorage, +getWebkitPersistentStorage, +#endif +getAppCodeName, +getAppName, +getAppVersion, +getLanguage, +getUserAgent, +getPlatform, +getPlugins, +getMimeTypes, +getProduct, +getProductSub, +getVendor, +getVendorSub, +getCookieEnabled, +getOnLine, +Navigator, +castToNavigator, +gTypeNavigator, +NavigatorClass, +toNavigator, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + + +#if WEBKIT_CHECK_VERSION(2,2,2) +registerProtocolHandler :: + (MonadIO m, NavigatorClass self, GlibString string) => + self -> string -> string -> string -> m () +registerProtocolHandler self scheme url title + = liftIO + (propagateGError $ + \ errorPtr_ -> + withUTFString title $ + \ titlePtr -> + withUTFString url $ + \ urlPtr -> + withUTFString scheme $ + \ schemePtr -> + {# call webkit_dom_navigator_register_protocol_handler #} + (toNavigator self) + schemePtr + urlPtr + titlePtr + errorPtr_) -navigatorJavaEnabled :: (NavigatorClass self) => self -> IO Bool -navigatorJavaEnabled self - = toBool <$> - ({# call webkit_dom_navigator_java_enabled #} (toNavigator self)) +isProtocolHandlerRegistered :: + (MonadIO m, NavigatorClass self, GlibString string) => + self -> string -> string -> m string +isProtocolHandlerRegistered self scheme url + = liftIO + ((propagateGError $ + \ errorPtr_ -> + withUTFString url $ + \ urlPtr -> + withUTFString scheme $ + \ schemePtr -> + {# call webkit_dom_navigator_is_protocol_handler_registered #} + (toNavigator self) + schemePtr + urlPtr + errorPtr_) + >>= + readUTFString) -navigatorGetStorageUpdates :: - (NavigatorClass self) => self -> IO () -navigatorGetStorageUpdates self - = {# call webkit_dom_navigator_get_storage_updates #} - (toNavigator self) +unregisterProtocolHandler :: + (MonadIO m, NavigatorClass self, GlibString string) => + self -> string -> string -> m () +unregisterProtocolHandler self scheme url + = liftIO + (propagateGError $ + \ errorPtr_ -> + withUTFString url $ + \ urlPtr -> + withUTFString scheme $ + \ schemePtr -> + {# call webkit_dom_navigator_unregister_protocol_handler #} + (toNavigator self) + schemePtr + urlPtr + errorPtr_) +#endif -navigatorGetAppCodeName :: - (NavigatorClass self) => self -> IO String -navigatorGetAppCodeName self - = ({# call webkit_dom_navigator_get_app_code_name #} - (toNavigator self)) - >>= - readUTFString +javaEnabled :: (MonadIO m, NavigatorClass self) => self -> m Bool +javaEnabled self + = liftIO + (toBool <$> + ({# call webkit_dom_navigator_java_enabled #} (toNavigator self))) -navigatorGetAppName :: (NavigatorClass self) => self -> IO String -navigatorGetAppName self - = ({# call webkit_dom_navigator_get_app_name #} (toNavigator self)) - >>= - readUTFString +getStorageUpdates :: + (MonadIO m, NavigatorClass self) => self -> m () +getStorageUpdates self + = liftIO + ({# call webkit_dom_navigator_get_storage_updates #} + (toNavigator self)) + +#if WEBKIT_CHECK_VERSION(2,2,2) +getWebkitBattery :: + (MonadIO m, NavigatorClass self) => + self -> m (Maybe BatteryManager) +getWebkitBattery self + = liftIO + (maybeNull (makeNewGObject mkBatteryManager) + ({# call webkit_dom_navigator_get_webkit_battery #} + (toNavigator self))) +#endif -navigatorGetAppVersion :: - (NavigatorClass self) => self -> IO String -navigatorGetAppVersion self - = ({# call webkit_dom_navigator_get_app_version #} - (toNavigator self)) - >>= - readUTFString +getGeolocation :: + (MonadIO m, NavigatorClass self) => self -> m (Maybe Geolocation) +getGeolocation self + = liftIO + (maybeNull (makeNewGObject mkGeolocation) + ({# call webkit_dom_navigator_get_geolocation #} + (toNavigator self))) + +#if WEBKIT_CHECK_VERSION(2,2,2) +getWebkitTemporaryStorage :: + (MonadIO m, NavigatorClass self) => self -> m (Maybe StorageQuota) +getWebkitTemporaryStorage self + = liftIO + (maybeNull (makeNewGObject mkStorageQuota) + ({# call webkit_dom_navigator_get_webkit_temporary_storage #} + (toNavigator self))) -navigatorGetLanguage :: (NavigatorClass self) => self -> IO String -navigatorGetLanguage self - = ({# call webkit_dom_navigator_get_language #} (toNavigator self)) - >>= - readUTFString +getWebkitPersistentStorage :: + (MonadIO m, NavigatorClass self) => self -> m (Maybe StorageQuota) +getWebkitPersistentStorage self + = liftIO + (maybeNull (makeNewGObject mkStorageQuota) + ({# call webkit_dom_navigator_get_webkit_persistent_storage #} + (toNavigator self))) +#endif -navigatorGetUserAgent :: (NavigatorClass self) => self -> IO String -navigatorGetUserAgent self - = ({# call webkit_dom_navigator_get_user_agent #} - (toNavigator self)) - >>= - readUTFString +getAppCodeName :: + (MonadIO m, NavigatorClass self, GlibString string) => + self -> m string +getAppCodeName self + = liftIO + (({# call webkit_dom_navigator_get_app_code_name #} + (toNavigator self)) + >>= + readUTFString) -navigatorGetPlatform :: (NavigatorClass self) => self -> IO String -navigatorGetPlatform self - = ({# call webkit_dom_navigator_get_platform #} (toNavigator self)) - >>= - readUTFString +getAppName :: + (MonadIO m, NavigatorClass self, GlibString string) => + self -> m string +getAppName self + = liftIO + (({# call webkit_dom_navigator_get_app_name #} (toNavigator self)) + >>= + readUTFString) -navigatorGetPlugins :: - (NavigatorClass self) => self -> IO (Maybe DOMPluginArray) -navigatorGetPlugins self - = maybeNull (makeNewGObject mkDOMPluginArray) - ({# call webkit_dom_navigator_get_plugins #} (toNavigator self)) +getAppVersion :: + (MonadIO m, NavigatorClass self, GlibString string) => + self -> m string +getAppVersion self + = liftIO + (({# call webkit_dom_navigator_get_app_version #} + (toNavigator self)) + >>= + readUTFString) -navigatorGetMimeTypes :: - (NavigatorClass self) => self -> IO (Maybe DOMMimeTypeArray) -navigatorGetMimeTypes self - = maybeNull (makeNewGObject mkDOMMimeTypeArray) - ({# call webkit_dom_navigator_get_mime_types #} (toNavigator self)) +getLanguage :: + (MonadIO m, NavigatorClass self, GlibString string) => + self -> m string +getLanguage self + = liftIO + (({# call webkit_dom_navigator_get_language #} (toNavigator self)) + >>= + readUTFString) -navigatorGetProduct :: (NavigatorClass self) => self -> IO String -navigatorGetProduct self - = ({# call webkit_dom_navigator_get_product #} (toNavigator self)) - >>= - readUTFString +getUserAgent :: + (MonadIO m, NavigatorClass self, GlibString string) => + self -> m string +getUserAgent self + = liftIO + (({# call webkit_dom_navigator_get_user_agent #} + (toNavigator self)) + >>= + readUTFString) -navigatorGetProductSub :: - (NavigatorClass self) => self -> IO String -navigatorGetProductSub self - = ({# call webkit_dom_navigator_get_product_sub #} - (toNavigator self)) - >>= - readUTFString +getPlatform :: + (MonadIO m, NavigatorClass self, GlibString string) => + self -> m string +getPlatform self + = liftIO + (({# call webkit_dom_navigator_get_platform #} (toNavigator self)) + >>= + readUTFString) -navigatorGetVendor :: (NavigatorClass self) => self -> IO String -navigatorGetVendor self - = ({# call webkit_dom_navigator_get_vendor #} (toNavigator self)) - >>= - readUTFString +getPlugins :: + (MonadIO m, NavigatorClass self) => self -> m (Maybe PluginArray) +getPlugins self + = liftIO + (maybeNull (makeNewGObject mkPluginArray) + ({# call webkit_dom_navigator_get_plugins #} (toNavigator self))) -navigatorGetVendorSub :: (NavigatorClass self) => self -> IO String -navigatorGetVendorSub self - = ({# call webkit_dom_navigator_get_vendor_sub #} - (toNavigator self)) - >>= - readUTFString +getMimeTypes :: + (MonadIO m, NavigatorClass self) => self -> m (Maybe MimeTypeArray) +getMimeTypes self + = liftIO + (maybeNull (makeNewGObject mkMimeTypeArray) + ({# call webkit_dom_navigator_get_mime_types #} + (toNavigator self))) -navigatorGetCookieEnabled :: - (NavigatorClass self) => self -> IO Bool -navigatorGetCookieEnabled self - = toBool <$> - ({# call webkit_dom_navigator_get_cookie_enabled #} - (toNavigator self)) +getProduct :: + (MonadIO m, NavigatorClass self, GlibString string) => + self -> m string +getProduct self + = liftIO + (({# call webkit_dom_navigator_get_product #} (toNavigator self)) + >>= + readUTFString) -navigatorGetOnLine :: (NavigatorClass self) => self -> IO Bool -navigatorGetOnLine self - = toBool <$> - ({# call webkit_dom_navigator_get_on_line #} (toNavigator self)) +getProductSub :: + (MonadIO m, NavigatorClass self, GlibString string) => + self -> m string +getProductSub self + = liftIO + (({# call webkit_dom_navigator_get_product_sub #} + (toNavigator self)) + >>= + readUTFString) + +getVendor :: + (MonadIO m, NavigatorClass self, GlibString string) => + self -> m string +getVendor self + = liftIO + (({# call webkit_dom_navigator_get_vendor #} (toNavigator self)) + >>= + readUTFString) + +getVendorSub :: + (MonadIO m, NavigatorClass self, GlibString string) => + self -> m string +getVendorSub self + = liftIO + (({# call webkit_dom_navigator_get_vendor_sub #} + (toNavigator self)) + >>= + readUTFString) + +getCookieEnabled :: + (MonadIO m, NavigatorClass self) => self -> m Bool +getCookieEnabled self + = liftIO + (toBool <$> + ({# call webkit_dom_navigator_get_cookie_enabled #} + (toNavigator self))) + +getOnLine :: (MonadIO m, NavigatorClass self) => self -> m Bool +getOnLine self + = liftIO + (toBool <$> + ({# call webkit_dom_navigator_get_on_line #} (toNavigator self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/Node.chs b/Graphics/UI/Gtk/WebKit/DOM/Node.chs --- a/Graphics/UI/Gtk/WebKit/DOM/Node.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/Node.chs @@ -1,297 +1,399 @@ -module Graphics.UI.Gtk.WebKit.DOM.Node - (nodeInsertBefore, nodeReplaceChild, nodeRemoveChild, - nodeAppendChild, nodeHasChildNodes, nodeCloneNode, nodeNormalize, - nodeIsSupported, nodeIsSameNode, nodeIsEqualNode, nodeLookupPrefix, - nodeIsDefaultNamespace, nodeLookupNamespaceURI, - nodeCompareDocumentPosition, nodeContains, nodeDispatchEvent, - cELEMENT_NODE, cATTRIBUTE_NODE, cTEXT_NODE, cCDATA_SECTION_NODE, - cENTITY_REFERENCE_NODE, cENTITY_NODE, cPROCESSING_INSTRUCTION_NODE, - cCOMMENT_NODE, cDOCUMENT_NODE, cDOCUMENT_TYPE_NODE, - cDOCUMENT_FRAGMENT_NODE, cNOTATION_NODE, - cDOCUMENT_POSITION_DISCONNECTED, cDOCUMENT_POSITION_PRECEDING, - cDOCUMENT_POSITION_FOLLOWING, cDOCUMENT_POSITION_CONTAINS, - cDOCUMENT_POSITION_CONTAINED_BY, - cDOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC, nodeGetNodeName, - nodeSetNodeValue, nodeGetNodeValue, nodeGetNodeType, - nodeGetParentNode, nodeGetChildNodes, nodeGetFirstChild, - nodeGetLastChild, nodeGetPreviousSibling, nodeGetNextSibling, - nodeGetOwnerDocument, nodeGetNamespaceURI, nodeSetPrefix, - nodeGetPrefix, nodeGetLocalName, nodeGetBaseURI, - nodeSetTextContent, nodeGetTextContent, nodeGetParentElement, Node, - NodeClass, castToNode, gTypeNode, toNode) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.Node( +insertBefore, +replaceChild, +removeChild, +appendChild, +hasChildNodes, +cloneNode, +normalize, +isSupported, +isSameNode, +isEqualNode, +lookupPrefix, +isDefaultNamespace, +lookupNamespaceURI, +compareDocumentPosition, +contains, +pattern ELEMENT_NODE, +pattern ATTRIBUTE_NODE, +pattern TEXT_NODE, +pattern CDATA_SECTION_NODE, +pattern ENTITY_REFERENCE_NODE, +pattern ENTITY_NODE, +pattern PROCESSING_INSTRUCTION_NODE, +pattern COMMENT_NODE, +pattern DOCUMENT_NODE, +pattern DOCUMENT_TYPE_NODE, +pattern DOCUMENT_FRAGMENT_NODE, +pattern NOTATION_NODE, +pattern DOCUMENT_POSITION_DISCONNECTED, +pattern DOCUMENT_POSITION_PRECEDING, +pattern DOCUMENT_POSITION_FOLLOWING, +pattern DOCUMENT_POSITION_CONTAINS, +pattern DOCUMENT_POSITION_CONTAINED_BY, +pattern DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC, +getNodeName, +setNodeValue, +getNodeValue, +getNodeType, +getParentNode, +getChildNodes, +getFirstChild, +getLastChild, +getPreviousSibling, +getNextSibling, +getOwnerDocument, +getNamespaceURI, +setPrefix, +getPrefix, +getLocalName, +getBaseURI, +setTextContent, +getTextContent, +getParentElement, +Node, +castToNode, +gTypeNode, +NodeClass, +toNode, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -nodeInsertBefore :: - (NodeClass self, NodeClass newChild, NodeClass refChild) => - self -> Maybe newChild -> Maybe refChild -> IO (Maybe Node) -nodeInsertBefore self newChild refChild - = maybeNull (makeNewGObject mkNode) - (propagateGError $ - \ errorPtr_ -> - {# call webkit_dom_node_insert_before #} (toNode self) - (maybe (Node nullForeignPtr) toNode newChild) - (maybe (Node nullForeignPtr) toNode refChild) - errorPtr_) +insertBefore :: + (MonadIO m, NodeClass self, NodeClass newChild, + NodeClass refChild) => + self -> Maybe newChild -> Maybe refChild -> m (Maybe Node) +insertBefore self newChild refChild + = liftIO + (maybeNull (makeNewGObject mkNode) + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_node_insert_before #} (toNode self) + (maybe (Node nullForeignPtr) toNode newChild) + (maybe (Node nullForeignPtr) toNode refChild) + errorPtr_)) -nodeReplaceChild :: - (NodeClass self, NodeClass newChild, NodeClass oldChild) => - self -> Maybe newChild -> Maybe oldChild -> IO (Maybe Node) -nodeReplaceChild self newChild oldChild - = maybeNull (makeNewGObject mkNode) - (propagateGError $ - \ errorPtr_ -> - {# call webkit_dom_node_replace_child #} (toNode self) - (maybe (Node nullForeignPtr) toNode newChild) - (maybe (Node nullForeignPtr) toNode oldChild) - errorPtr_) +replaceChild :: + (MonadIO m, NodeClass self, NodeClass newChild, + NodeClass oldChild) => + self -> Maybe newChild -> Maybe oldChild -> m (Maybe Node) +replaceChild self newChild oldChild + = liftIO + (maybeNull (makeNewGObject mkNode) + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_node_replace_child #} (toNode self) + (maybe (Node nullForeignPtr) toNode newChild) + (maybe (Node nullForeignPtr) toNode oldChild) + errorPtr_)) -nodeRemoveChild :: - (NodeClass self, NodeClass oldChild) => - self -> Maybe oldChild -> IO (Maybe Node) -nodeRemoveChild self oldChild - = maybeNull (makeNewGObject mkNode) - (propagateGError $ - \ errorPtr_ -> - {# call webkit_dom_node_remove_child #} (toNode self) - (maybe (Node nullForeignPtr) toNode oldChild) - errorPtr_) +removeChild :: + (MonadIO m, NodeClass self, NodeClass oldChild) => + self -> Maybe oldChild -> m (Maybe Node) +removeChild self oldChild + = liftIO + (maybeNull (makeNewGObject mkNode) + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_node_remove_child #} (toNode self) + (maybe (Node nullForeignPtr) toNode oldChild) + errorPtr_)) -nodeAppendChild :: - (NodeClass self, NodeClass newChild) => - self -> Maybe newChild -> IO (Maybe Node) -nodeAppendChild self newChild - = maybeNull (makeNewGObject mkNode) - (propagateGError $ - \ errorPtr_ -> - {# call webkit_dom_node_append_child #} (toNode self) - (maybe (Node nullForeignPtr) toNode newChild) - errorPtr_) +appendChild :: + (MonadIO m, NodeClass self, NodeClass newChild) => + self -> Maybe newChild -> m (Maybe Node) +appendChild self newChild + = liftIO + (maybeNull (makeNewGObject mkNode) + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_node_append_child #} (toNode self) + (maybe (Node nullForeignPtr) toNode newChild) + errorPtr_)) -nodeHasChildNodes :: (NodeClass self) => self -> IO Bool -nodeHasChildNodes self - = toBool <$> - ({# call webkit_dom_node_has_child_nodes #} (toNode self)) +hasChildNodes :: (MonadIO m, NodeClass self) => self -> m Bool +hasChildNodes self + = liftIO + (toBool <$> + ({# call webkit_dom_node_has_child_nodes #} (toNode self))) -nodeCloneNode :: - (NodeClass self) => self -> Bool -> IO (Maybe Node) -nodeCloneNode self deep - = maybeNull (makeNewGObject mkNode) - ({# call webkit_dom_node_clone_node #} (toNode self) - (fromBool deep)) +cloneNode :: + (MonadIO m, NodeClass self) => self -> Bool -> m (Maybe Node) +cloneNode self deep + = liftIO + (maybeNull (makeNewGObject mkNode) + ({# call webkit_dom_node_clone_node #} (toNode self) + (fromBool deep))) -nodeNormalize :: (NodeClass self) => self -> IO () -nodeNormalize self - = {# call webkit_dom_node_normalize #} (toNode self) +normalize :: (MonadIO m, NodeClass self) => self -> m () +normalize self + = liftIO ({# call webkit_dom_node_normalize #} (toNode self)) -nodeIsSupported :: - (NodeClass self) => self -> String -> String -> IO Bool -nodeIsSupported self feature version - = toBool <$> - (withUTFString version $ - \ versionPtr -> - withUTFString feature $ - \ featurePtr -> - {# call webkit_dom_node_is_supported #} (toNode self) featurePtr - versionPtr) +isSupported :: + (MonadIO m, NodeClass self, GlibString string) => + self -> string -> (Maybe string) -> m Bool +isSupported self feature version + = liftIO + (toBool <$> + (maybeWith withUTFString version $ + \ versionPtr -> + withUTFString feature $ + \ featurePtr -> + {# call webkit_dom_node_is_supported #} (toNode self) featurePtr + versionPtr)) -nodeIsSameNode :: - (NodeClass self, NodeClass other) => self -> Maybe other -> IO Bool -nodeIsSameNode self other - = toBool <$> - ({# call webkit_dom_node_is_same_node #} (toNode self) - (maybe (Node nullForeignPtr) toNode other)) +isSameNode :: + (MonadIO m, NodeClass self, NodeClass other) => + self -> Maybe other -> m Bool +isSameNode self other + = liftIO + (toBool <$> + ({# call webkit_dom_node_is_same_node #} (toNode self) + (maybe (Node nullForeignPtr) toNode other))) -nodeIsEqualNode :: - (NodeClass self, NodeClass other) => self -> Maybe other -> IO Bool -nodeIsEqualNode self other - = toBool <$> - ({# call webkit_dom_node_is_equal_node #} (toNode self) - (maybe (Node nullForeignPtr) toNode other)) +isEqualNode :: + (MonadIO m, NodeClass self, NodeClass other) => + self -> Maybe other -> m Bool +isEqualNode self other + = liftIO + (toBool <$> + ({# call webkit_dom_node_is_equal_node #} (toNode self) + (maybe (Node nullForeignPtr) toNode other))) -nodeLookupPrefix :: (NodeClass self) => self -> String -> IO String -nodeLookupPrefix self namespaceURI - = (withUTFString namespaceURI $ - \ namespaceURIPtr -> - {# call webkit_dom_node_lookup_prefix #} (toNode self) - namespaceURIPtr) - >>= - readUTFString +lookupPrefix :: + (MonadIO m, NodeClass self, GlibString string) => + self -> (Maybe string) -> m (Maybe string) +lookupPrefix self namespaceURI + = liftIO + ((maybeWith withUTFString namespaceURI $ + \ namespaceURIPtr -> + {# call webkit_dom_node_lookup_prefix #} (toNode self) + namespaceURIPtr) + >>= + maybePeek readUTFString) -nodeIsDefaultNamespace :: - (NodeClass self) => self -> String -> IO Bool -nodeIsDefaultNamespace self namespaceURI - = toBool <$> - (withUTFString namespaceURI $ - \ namespaceURIPtr -> - {# call webkit_dom_node_is_default_namespace #} (toNode self) - namespaceURIPtr) +isDefaultNamespace :: + (MonadIO m, NodeClass self, GlibString string) => + self -> (Maybe string) -> m Bool +isDefaultNamespace self namespaceURI + = liftIO + (toBool <$> + (maybeWith withUTFString namespaceURI $ + \ namespaceURIPtr -> + {# call webkit_dom_node_is_default_namespace #} (toNode self) + namespaceURIPtr)) -nodeLookupNamespaceURI :: - (NodeClass self) => self -> String -> IO String -nodeLookupNamespaceURI self prefix - = (withUTFString prefix $ - \ prefixPtr -> - {# call webkit_dom_node_lookup_namespace_uri #} (toNode self) - prefixPtr) - >>= - readUTFString +lookupNamespaceURI :: + (MonadIO m, NodeClass self, GlibString string) => + self -> (Maybe string) -> m (Maybe string) +lookupNamespaceURI self prefix + = liftIO + ((maybeWith withUTFString prefix $ + \ prefixPtr -> + {# call webkit_dom_node_lookup_namespace_uri #} (toNode self) + prefixPtr) + >>= + maybePeek readUTFString) -nodeCompareDocumentPosition :: - (NodeClass self, NodeClass other) => self -> Maybe other -> IO Word -nodeCompareDocumentPosition self other - = fromIntegral <$> - ({# call webkit_dom_node_compare_document_position #} (toNode self) - (maybe (Node nullForeignPtr) toNode other)) +compareDocumentPosition :: + (MonadIO m, NodeClass self, NodeClass other) => + self -> Maybe other -> m Word +compareDocumentPosition self other + = liftIO + (fromIntegral <$> + ({# call webkit_dom_node_compare_document_position #} (toNode self) + (maybe (Node nullForeignPtr) toNode other))) -nodeContains :: - (NodeClass self, NodeClass other) => self -> Maybe other -> IO Bool -nodeContains self other - = toBool <$> - ({# call webkit_dom_node_contains #} (toNode self) - (maybe (Node nullForeignPtr) toNode other)) +contains :: + (MonadIO m, NodeClass self, NodeClass other) => + self -> Maybe other -> m Bool +contains self other + = liftIO + (toBool <$> + ({# call webkit_dom_node_contains #} (toNode self) + (maybe (Node nullForeignPtr) toNode other))) +pattern ELEMENT_NODE = 1 +pattern ATTRIBUTE_NODE = 2 +pattern TEXT_NODE = 3 +pattern CDATA_SECTION_NODE = 4 +pattern ENTITY_REFERENCE_NODE = 5 +pattern ENTITY_NODE = 6 +pattern PROCESSING_INSTRUCTION_NODE = 7 +pattern COMMENT_NODE = 8 +pattern DOCUMENT_NODE = 9 +pattern DOCUMENT_TYPE_NODE = 10 +pattern DOCUMENT_FRAGMENT_NODE = 11 +pattern NOTATION_NODE = 12 +pattern DOCUMENT_POSITION_DISCONNECTED = 1 +pattern DOCUMENT_POSITION_PRECEDING = 2 +pattern DOCUMENT_POSITION_FOLLOWING = 4 +pattern DOCUMENT_POSITION_CONTAINS = 8 +pattern DOCUMENT_POSITION_CONTAINED_BY = 16 +pattern DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC = 32 -nodeDispatchEvent :: - (NodeClass self, EventClass event) => - self -> Maybe event -> IO Bool -nodeDispatchEvent self event - = toBool <$> +getNodeName :: + (MonadIO m, NodeClass self, GlibString string) => + self -> m (Maybe string) +getNodeName self + = liftIO + (({# call webkit_dom_node_get_node_name #} (toNode self)) >>= + maybePeek readUTFString) + +setNodeValue :: + (MonadIO m, NodeClass self, GlibString string) => + self -> (Maybe string) -> m () +setNodeValue self val + = liftIO (propagateGError $ \ errorPtr_ -> - {# call webkit_dom_node_dispatch_event #} (toNode self) - (maybe (Event nullForeignPtr) toEvent event) + maybeWith withUTFString val $ + \ valPtr -> + {# call webkit_dom_node_set_node_value #} (toNode self) valPtr errorPtr_) -cELEMENT_NODE = 1 -cATTRIBUTE_NODE = 2 -cTEXT_NODE = 3 -cCDATA_SECTION_NODE = 4 -cENTITY_REFERENCE_NODE = 5 -cENTITY_NODE = 6 -cPROCESSING_INSTRUCTION_NODE = 7 -cCOMMENT_NODE = 8 -cDOCUMENT_NODE = 9 -cDOCUMENT_TYPE_NODE = 10 -cDOCUMENT_FRAGMENT_NODE = 11 -cNOTATION_NODE = 12 -cDOCUMENT_POSITION_DISCONNECTED = 1 -cDOCUMENT_POSITION_PRECEDING = 2 -cDOCUMENT_POSITION_FOLLOWING = 4 -cDOCUMENT_POSITION_CONTAINS = 8 -cDOCUMENT_POSITION_CONTAINED_BY = 16 -cDOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC = 32 -nodeGetNodeName :: (NodeClass self) => self -> IO String -nodeGetNodeName self - = ({# call webkit_dom_node_get_node_name #} (toNode self)) >>= - readUTFString - -nodeSetNodeValue :: (NodeClass self) => self -> String -> IO () -nodeSetNodeValue self val - = propagateGError $ - \ errorPtr_ -> - withUTFString val $ - \ valPtr -> - {# call webkit_dom_node_set_node_value #} (toNode self) valPtr - errorPtr_ - -nodeGetNodeValue :: (NodeClass self) => self -> IO String -nodeGetNodeValue self - = ({# call webkit_dom_node_get_node_value #} (toNode self)) >>= - readUTFString +getNodeValue :: + (MonadIO m, NodeClass self, GlibString string) => + self -> m (Maybe string) +getNodeValue self + = liftIO + (({# call webkit_dom_node_get_node_value #} (toNode self)) >>= + maybePeek readUTFString) -nodeGetNodeType :: (NodeClass self) => self -> IO Word -nodeGetNodeType self - = fromIntegral <$> - ({# call webkit_dom_node_get_node_type #} (toNode self)) +getNodeType :: (MonadIO m, NodeClass self) => self -> m Word +getNodeType self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_node_get_node_type #} (toNode self))) -nodeGetParentNode :: (NodeClass self) => self -> IO (Maybe Node) -nodeGetParentNode self - = maybeNull (makeNewGObject mkNode) - ({# call webkit_dom_node_get_parent_node #} (toNode self)) +getParentNode :: + (MonadIO m, NodeClass self) => self -> m (Maybe Node) +getParentNode self + = liftIO + (maybeNull (makeNewGObject mkNode) + ({# call webkit_dom_node_get_parent_node #} (toNode self))) -nodeGetChildNodes :: - (NodeClass self) => self -> IO (Maybe NodeList) -nodeGetChildNodes self - = maybeNull (makeNewGObject mkNodeList) - ({# call webkit_dom_node_get_child_nodes #} (toNode self)) +getChildNodes :: + (MonadIO m, NodeClass self) => self -> m (Maybe NodeList) +getChildNodes self + = liftIO + (maybeNull (makeNewGObject mkNodeList) + ({# call webkit_dom_node_get_child_nodes #} (toNode self))) -nodeGetFirstChild :: (NodeClass self) => self -> IO (Maybe Node) -nodeGetFirstChild self - = maybeNull (makeNewGObject mkNode) - ({# call webkit_dom_node_get_first_child #} (toNode self)) +getFirstChild :: + (MonadIO m, NodeClass self) => self -> m (Maybe Node) +getFirstChild self + = liftIO + (maybeNull (makeNewGObject mkNode) + ({# call webkit_dom_node_get_first_child #} (toNode self))) -nodeGetLastChild :: (NodeClass self) => self -> IO (Maybe Node) -nodeGetLastChild self - = maybeNull (makeNewGObject mkNode) - ({# call webkit_dom_node_get_last_child #} (toNode self)) +getLastChild :: + (MonadIO m, NodeClass self) => self -> m (Maybe Node) +getLastChild self + = liftIO + (maybeNull (makeNewGObject mkNode) + ({# call webkit_dom_node_get_last_child #} (toNode self))) -nodeGetPreviousSibling :: - (NodeClass self) => self -> IO (Maybe Node) -nodeGetPreviousSibling self - = maybeNull (makeNewGObject mkNode) - ({# call webkit_dom_node_get_previous_sibling #} (toNode self)) +getPreviousSibling :: + (MonadIO m, NodeClass self) => self -> m (Maybe Node) +getPreviousSibling self + = liftIO + (maybeNull (makeNewGObject mkNode) + ({# call webkit_dom_node_get_previous_sibling #} (toNode self))) -nodeGetNextSibling :: (NodeClass self) => self -> IO (Maybe Node) -nodeGetNextSibling self - = maybeNull (makeNewGObject mkNode) - ({# call webkit_dom_node_get_next_sibling #} (toNode self)) +getNextSibling :: + (MonadIO m, NodeClass self) => self -> m (Maybe Node) +getNextSibling self + = liftIO + (maybeNull (makeNewGObject mkNode) + ({# call webkit_dom_node_get_next_sibling #} (toNode self))) -nodeGetOwnerDocument :: - (NodeClass self) => self -> IO (Maybe Document) -nodeGetOwnerDocument self - = maybeNull (makeNewGObject mkDocument) - ({# call webkit_dom_node_get_owner_document #} (toNode self)) +getOwnerDocument :: + (MonadIO m, NodeClass self) => self -> m (Maybe Document) +getOwnerDocument self + = liftIO + (maybeNull (makeNewGObject mkDocument) + ({# call webkit_dom_node_get_owner_document #} (toNode self))) -nodeGetNamespaceURI :: (NodeClass self) => self -> IO String -nodeGetNamespaceURI self - = ({# call webkit_dom_node_get_namespace_uri #} (toNode self)) >>= - readUTFString +getNamespaceURI :: + (MonadIO m, NodeClass self, GlibString string) => + self -> m (Maybe string) +getNamespaceURI self + = liftIO + (({# call webkit_dom_node_get_namespace_uri #} (toNode self)) >>= + maybePeek readUTFString) -nodeSetPrefix :: (NodeClass self) => self -> String -> IO () -nodeSetPrefix self val - = propagateGError $ - \ errorPtr_ -> - withUTFString val $ - \ valPtr -> - {# call webkit_dom_node_set_prefix #} (toNode self) valPtr - errorPtr_ +setPrefix :: + (MonadIO m, NodeClass self, GlibString string) => + self -> (Maybe string) -> m () +setPrefix self val + = liftIO + (propagateGError $ + \ errorPtr_ -> + maybeWith withUTFString val $ + \ valPtr -> + {# call webkit_dom_node_set_prefix #} (toNode self) valPtr + errorPtr_) -nodeGetPrefix :: (NodeClass self) => self -> IO String -nodeGetPrefix self - = ({# call webkit_dom_node_get_prefix #} (toNode self)) >>= - readUTFString +getPrefix :: + (MonadIO m, NodeClass self, GlibString string) => + self -> m (Maybe string) +getPrefix self + = liftIO + (({# call webkit_dom_node_get_prefix #} (toNode self)) >>= + maybePeek readUTFString) -nodeGetLocalName :: (NodeClass self) => self -> IO String -nodeGetLocalName self - = ({# call webkit_dom_node_get_local_name #} (toNode self)) >>= - readUTFString +getLocalName :: + (MonadIO m, NodeClass self, GlibString string) => + self -> m (Maybe string) +getLocalName self + = liftIO + (({# call webkit_dom_node_get_local_name #} (toNode self)) >>= + maybePeek readUTFString) -nodeGetBaseURI :: (NodeClass self) => self -> IO String -nodeGetBaseURI self - = ({# call webkit_dom_node_get_base_uri #} (toNode self)) >>= - readUTFString +getBaseURI :: + (MonadIO m, NodeClass self, GlibString string) => + self -> m (Maybe string) +getBaseURI self + = liftIO + (({# call webkit_dom_node_get_base_uri #} (toNode self)) >>= + maybePeek readUTFString) -nodeSetTextContent :: (NodeClass self) => self -> String -> IO () -nodeSetTextContent self val - = propagateGError $ - \ errorPtr_ -> - withUTFString val $ - \ valPtr -> - {# call webkit_dom_node_set_text_content #} (toNode self) valPtr - errorPtr_ +setTextContent :: + (MonadIO m, NodeClass self, GlibString string) => + self -> (Maybe string) -> m () +setTextContent self val + = liftIO + (propagateGError $ + \ errorPtr_ -> + maybeWith withUTFString val $ + \ valPtr -> + {# call webkit_dom_node_set_text_content #} (toNode self) valPtr + errorPtr_) -nodeGetTextContent :: (NodeClass self) => self -> IO String -nodeGetTextContent self - = ({# call webkit_dom_node_get_text_content #} (toNode self)) >>= - readUTFString +getTextContent :: + (MonadIO m, NodeClass self, GlibString string) => + self -> m (Maybe string) +getTextContent self + = liftIO + (({# call webkit_dom_node_get_text_content #} (toNode self)) >>= + maybePeek readUTFString) -nodeGetParentElement :: - (NodeClass self) => self -> IO (Maybe Element) -nodeGetParentElement self - = maybeNull (makeNewGObject mkElement) - ({# call webkit_dom_node_get_parent_element #} (toNode self)) +getParentElement :: + (MonadIO m, NodeClass self) => self -> m (Maybe Element) +getParentElement self + = liftIO + (maybeNull (makeNewGObject mkElement) + ({# call webkit_dom_node_get_parent_element #} (toNode self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/NodeFilter.chs b/Graphics/UI/Gtk/WebKit/DOM/NodeFilter.chs --- a/Graphics/UI/Gtk/WebKit/DOM/NodeFilter.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/NodeFilter.chs @@ -1,30 +1,53 @@ -module Graphics.UI.Gtk.WebKit.DOM.NodeFilter - (cFILTER_ACCEPT, cFILTER_REJECT, cFILTER_SKIP, cSHOW_ALL, - cSHOW_ELEMENT, cSHOW_ATTRIBUTE, cSHOW_TEXT, cSHOW_CDATA_SECTION, - cSHOW_ENTITY_REFERENCE, cSHOW_ENTITY, cSHOW_PROCESSING_INSTRUCTION, - cSHOW_COMMENT, cSHOW_DOCUMENT, cSHOW_DOCUMENT_TYPE, - cSHOW_DOCUMENT_FRAGMENT, cSHOW_NOTATION, NodeFilter, - NodeFilterClass, castToNodeFilter, gTypeNodeFilter, toNodeFilter) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.NodeFilter( +pattern FILTER_ACCEPT, +pattern FILTER_REJECT, +pattern FILTER_SKIP, +pattern SHOW_ALL, +pattern SHOW_ELEMENT, +pattern SHOW_ATTRIBUTE, +pattern SHOW_TEXT, +pattern SHOW_CDATA_SECTION, +pattern SHOW_ENTITY_REFERENCE, +pattern SHOW_ENTITY, +pattern SHOW_PROCESSING_INSTRUCTION, +pattern SHOW_COMMENT, +pattern SHOW_DOCUMENT, +pattern SHOW_DOCUMENT_TYPE, +pattern SHOW_DOCUMENT_FRAGMENT, +pattern SHOW_NOTATION, +NodeFilter, +castToNodeFilter, +gTypeNodeFilter, +NodeFilterClass, +toNodeFilter, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM -cFILTER_ACCEPT = 1 -cFILTER_REJECT = 2 -cFILTER_SKIP = 3 -cSHOW_ALL = 4294967295 -cSHOW_ELEMENT = 1 -cSHOW_ATTRIBUTE = 2 -cSHOW_TEXT = 4 -cSHOW_CDATA_SECTION = 8 -cSHOW_ENTITY_REFERENCE = 16 -cSHOW_ENTITY = 32 -cSHOW_PROCESSING_INSTRUCTION = 64 -cSHOW_COMMENT = 128 -cSHOW_DOCUMENT = 256 -cSHOW_DOCUMENT_TYPE = 512 -cSHOW_DOCUMENT_FRAGMENT = 1024 -cSHOW_NOTATION = 2048 +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + +pattern FILTER_ACCEPT = 1 +pattern FILTER_REJECT = 2 +pattern FILTER_SKIP = 3 +pattern SHOW_ALL = 4294967295 +pattern SHOW_ELEMENT = 1 +pattern SHOW_ATTRIBUTE = 2 +pattern SHOW_TEXT = 4 +pattern SHOW_CDATA_SECTION = 8 +pattern SHOW_ENTITY_REFERENCE = 16 +pattern SHOW_ENTITY = 32 +pattern SHOW_PROCESSING_INSTRUCTION = 64 +pattern SHOW_COMMENT = 128 +pattern SHOW_DOCUMENT = 256 +pattern SHOW_DOCUMENT_TYPE = 512 +pattern SHOW_DOCUMENT_FRAGMENT = 1024 +pattern SHOW_NOTATION = 2048 diff --git a/Graphics/UI/Gtk/WebKit/DOM/NodeIterator.chs b/Graphics/UI/Gtk/WebKit/DOM/NodeIterator.chs --- a/Graphics/UI/Gtk/WebKit/DOM/NodeIterator.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/NodeIterator.chs @@ -1,62 +1,82 @@ -module Graphics.UI.Gtk.WebKit.DOM.NodeIterator - (nodeIteratorDetach, nodeIteratorGetRoot, - nodeIteratorGetWhatToShow, nodeIteratorGetFilter, - nodeIteratorGetExpandEntityReferences, - nodeIteratorGetReferenceNode, - nodeIteratorGetPointerBeforeReferenceNode, NodeIterator, - NodeIteratorClass, castToNodeIterator, gTypeNodeIterator, - toNodeIterator) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.NodeIterator( +detach, +getRoot, +getWhatToShow, +getFilter, +getExpandEntityReferences, +getReferenceNode, +getPointerBeforeReferenceNode, +NodeIterator, +castToNodeIterator, +gTypeNodeIterator, +NodeIteratorClass, +toNodeIterator, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -nodeIteratorDetach :: (NodeIteratorClass self) => self -> IO () -nodeIteratorDetach self - = {# call webkit_dom_node_iterator_detach #} (toNodeIterator self) +detach :: (MonadIO m, NodeIteratorClass self) => self -> m () +detach self + = liftIO + ({# call webkit_dom_node_iterator_detach #} (toNodeIterator self)) -nodeIteratorGetRoot :: - (NodeIteratorClass self) => self -> IO (Maybe Node) -nodeIteratorGetRoot self - = maybeNull (makeNewGObject mkNode) - ({# call webkit_dom_node_iterator_get_root #} - (toNodeIterator self)) +getRoot :: + (MonadIO m, NodeIteratorClass self) => self -> m (Maybe Node) +getRoot self + = liftIO + (maybeNull (makeNewGObject mkNode) + ({# call webkit_dom_node_iterator_get_root #} + (toNodeIterator self))) -nodeIteratorGetWhatToShow :: - (NodeIteratorClass self) => self -> IO Word -nodeIteratorGetWhatToShow self - = fromIntegral <$> - ({# call webkit_dom_node_iterator_get_what_to_show #} - (toNodeIterator self)) +getWhatToShow :: + (MonadIO m, NodeIteratorClass self) => self -> m Word +getWhatToShow self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_node_iterator_get_what_to_show #} + (toNodeIterator self))) -nodeIteratorGetFilter :: - (NodeIteratorClass self) => self -> IO (Maybe NodeFilter) -nodeIteratorGetFilter self - = maybeNull (makeNewGObject mkNodeFilter) - ({# call webkit_dom_node_iterator_get_filter #} - (toNodeIterator self)) +getFilter :: + (MonadIO m, NodeIteratorClass self) => self -> m (Maybe NodeFilter) +getFilter self + = liftIO + (maybeNull (makeNewGObject mkNodeFilter) + ({# call webkit_dom_node_iterator_get_filter #} + (toNodeIterator self))) -nodeIteratorGetExpandEntityReferences :: - (NodeIteratorClass self) => self -> IO Bool -nodeIteratorGetExpandEntityReferences self - = toBool <$> - ({# call webkit_dom_node_iterator_get_expand_entity_references #} - (toNodeIterator self)) +getExpandEntityReferences :: + (MonadIO m, NodeIteratorClass self) => self -> m Bool +getExpandEntityReferences self + = liftIO + (toBool <$> + ({# call webkit_dom_node_iterator_get_expand_entity_references #} + (toNodeIterator self))) -nodeIteratorGetReferenceNode :: - (NodeIteratorClass self) => self -> IO (Maybe Node) -nodeIteratorGetReferenceNode self - = maybeNull (makeNewGObject mkNode) - ({# call webkit_dom_node_iterator_get_reference_node #} - (toNodeIterator self)) +getReferenceNode :: + (MonadIO m, NodeIteratorClass self) => self -> m (Maybe Node) +getReferenceNode self + = liftIO + (maybeNull (makeNewGObject mkNode) + ({# call webkit_dom_node_iterator_get_reference_node #} + (toNodeIterator self))) -nodeIteratorGetPointerBeforeReferenceNode :: - (NodeIteratorClass self) => self -> IO Bool -nodeIteratorGetPointerBeforeReferenceNode self - = toBool <$> - ({# call webkit_dom_node_iterator_get_pointer_before_reference_node - #} - (toNodeIterator self)) +getPointerBeforeReferenceNode :: + (MonadIO m, NodeIteratorClass self) => self -> m Bool +getPointerBeforeReferenceNode self + = liftIO + (toBool <$> + ({# call webkit_dom_node_iterator_get_pointer_before_reference_node + #} + (toNodeIterator self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/NodeList.chs b/Graphics/UI/Gtk/WebKit/DOM/NodeList.chs --- a/Graphics/UI/Gtk/WebKit/DOM/NodeList.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/NodeList.chs @@ -1,22 +1,37 @@ -module Graphics.UI.Gtk.WebKit.DOM.NodeList - (nodeListItem, nodeListGetLength, NodeList, NodeListClass, - castToNodeList, gTypeNodeList, toNodeList) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.NodeList( +item, +getLength, +NodeList, +castToNodeList, +gTypeNodeList, +NodeListClass, +toNodeList, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -nodeListItem :: - (NodeListClass self) => self -> Word -> IO (Maybe Node) -nodeListItem self index - = maybeNull (makeNewGObject mkNode) - ({# call webkit_dom_node_list_item #} (toNodeList self) - (fromIntegral index)) +item :: + (MonadIO m, NodeListClass self) => self -> Word -> m (Maybe Node) +item self index + = liftIO + (maybeNull (makeNewGObject mkNode) + ({# call webkit_dom_node_list_item #} (toNodeList self) + (fromIntegral index))) -nodeListGetLength :: (NodeListClass self) => self -> IO Word -nodeListGetLength self - = fromIntegral <$> - ({# call webkit_dom_node_list_get_length #} (toNodeList self)) +getLength :: (MonadIO m, NodeListClass self) => self -> m Word +getLength self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_node_list_get_length #} (toNodeList self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/Performance.chs b/Graphics/UI/Gtk/WebKit/DOM/Performance.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/Performance.chs @@ -0,0 +1,52 @@ +module Graphics.UI.Gtk.WebKit.DOM.Performance( +#if WEBKIT_CHECK_VERSION(2,2,2) +now, +getNavigation, +getTiming, +Performance, +castToPerformance, +gTypePerformance, +PerformanceClass, +toPerformance, +#endif +) where +#if WEBKIT_CHECK_VERSION(2,2,2) +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures +import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + + +now :: (MonadIO m, PerformanceClass self) => self -> m Double +now self + = liftIO + (realToFrac <$> + ({# call webkit_dom_performance_now #} (toPerformance self))) + +getNavigation :: + (MonadIO m, PerformanceClass self) => + self -> m (Maybe PerformanceNavigation) +getNavigation self + = liftIO + (maybeNull (makeNewGObject mkPerformanceNavigation) + ({# call webkit_dom_performance_get_navigation #} + (toPerformance self))) + +getTiming :: + (MonadIO m, PerformanceClass self) => + self -> m (Maybe PerformanceTiming) +getTiming self + = liftIO + (maybeNull (makeNewGObject mkPerformanceTiming) + ({# call webkit_dom_performance_get_timing #} + (toPerformance self))) +#endif diff --git a/Graphics/UI/Gtk/WebKit/DOM/PerformanceNavigation.chs b/Graphics/UI/Gtk/WebKit/DOM/PerformanceNavigation.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/PerformanceNavigation.chs @@ -0,0 +1,42 @@ +module Graphics.UI.Gtk.WebKit.DOM.PerformanceNavigation( +#if WEBKIT_CHECK_VERSION(2,2,2) +pattern TYPE_NAVIGATE, +pattern TYPE_RELOAD, +pattern TYPE_BACK_FORWARD, +pattern TYPE_RESERVED, +getRedirectCount, +PerformanceNavigation, +castToPerformanceNavigation, +gTypePerformanceNavigation, +PerformanceNavigationClass, +toPerformanceNavigation, +#endif +) where +#if WEBKIT_CHECK_VERSION(2,2,2) +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures +import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + +pattern TYPE_NAVIGATE = 0 +pattern TYPE_RELOAD = 1 +pattern TYPE_BACK_FORWARD = 2 +pattern TYPE_RESERVED = 255 + +getRedirectCount :: + (MonadIO m, PerformanceNavigationClass self) => self -> m Word +getRedirectCount self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_performance_navigation_get_redirect_count #} + (toPerformanceNavigation self))) +#endif diff --git a/Graphics/UI/Gtk/WebKit/DOM/PerformanceTiming.chs b/Graphics/UI/Gtk/WebKit/DOM/PerformanceTiming.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/PerformanceTiming.chs @@ -0,0 +1,219 @@ +module Graphics.UI.Gtk.WebKit.DOM.PerformanceTiming( +#if WEBKIT_CHECK_VERSION(2,2,2) +getNavigationStart, +getUnloadEventStart, +getUnloadEventEnd, +getRedirectStart, +getRedirectEnd, +getFetchStart, +getDomainLookupStart, +getDomainLookupEnd, +getConnectStart, +getConnectEnd, +getSecureConnectionStart, +getRequestStart, +getResponseStart, +getResponseEnd, +getDomLoading, +getDomInteractive, +getDomContentLoadedEventStart, +getDomContentLoadedEventEnd, +getDomComplete, +getLoadEventStart, +getLoadEventEnd, +PerformanceTiming, +castToPerformanceTiming, +gTypePerformanceTiming, +PerformanceTimingClass, +toPerformanceTiming, +#endif +) where +#if WEBKIT_CHECK_VERSION(2,2,2) +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures +import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + + +getNavigationStart :: + (MonadIO m, PerformanceTimingClass self) => self -> m Word64 +getNavigationStart self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_performance_timing_get_navigation_start #} + (toPerformanceTiming self))) + +getUnloadEventStart :: + (MonadIO m, PerformanceTimingClass self) => self -> m Word64 +getUnloadEventStart self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_performance_timing_get_unload_event_start #} + (toPerformanceTiming self))) + +getUnloadEventEnd :: + (MonadIO m, PerformanceTimingClass self) => self -> m Word64 +getUnloadEventEnd self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_performance_timing_get_unload_event_end #} + (toPerformanceTiming self))) + +getRedirectStart :: + (MonadIO m, PerformanceTimingClass self) => self -> m Word64 +getRedirectStart self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_performance_timing_get_redirect_start #} + (toPerformanceTiming self))) + +getRedirectEnd :: + (MonadIO m, PerformanceTimingClass self) => self -> m Word64 +getRedirectEnd self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_performance_timing_get_redirect_end #} + (toPerformanceTiming self))) + +getFetchStart :: + (MonadIO m, PerformanceTimingClass self) => self -> m Word64 +getFetchStart self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_performance_timing_get_fetch_start #} + (toPerformanceTiming self))) + +getDomainLookupStart :: + (MonadIO m, PerformanceTimingClass self) => self -> m Word64 +getDomainLookupStart self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_performance_timing_get_domain_lookup_start #} + (toPerformanceTiming self))) + +getDomainLookupEnd :: + (MonadIO m, PerformanceTimingClass self) => self -> m Word64 +getDomainLookupEnd self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_performance_timing_get_domain_lookup_end #} + (toPerformanceTiming self))) + +getConnectStart :: + (MonadIO m, PerformanceTimingClass self) => self -> m Word64 +getConnectStart self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_performance_timing_get_connect_start #} + (toPerformanceTiming self))) + +getConnectEnd :: + (MonadIO m, PerformanceTimingClass self) => self -> m Word64 +getConnectEnd self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_performance_timing_get_connect_end #} + (toPerformanceTiming self))) + +getSecureConnectionStart :: + (MonadIO m, PerformanceTimingClass self) => self -> m Word64 +getSecureConnectionStart self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_performance_timing_get_secure_connection_start + #} + (toPerformanceTiming self))) + +getRequestStart :: + (MonadIO m, PerformanceTimingClass self) => self -> m Word64 +getRequestStart self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_performance_timing_get_request_start #} + (toPerformanceTiming self))) + +getResponseStart :: + (MonadIO m, PerformanceTimingClass self) => self -> m Word64 +getResponseStart self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_performance_timing_get_response_start #} + (toPerformanceTiming self))) + +getResponseEnd :: + (MonadIO m, PerformanceTimingClass self) => self -> m Word64 +getResponseEnd self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_performance_timing_get_response_end #} + (toPerformanceTiming self))) + +getDomLoading :: + (MonadIO m, PerformanceTimingClass self) => self -> m Word64 +getDomLoading self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_performance_timing_get_dom_loading #} + (toPerformanceTiming self))) + +getDomInteractive :: + (MonadIO m, PerformanceTimingClass self) => self -> m Word64 +getDomInteractive self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_performance_timing_get_dom_interactive #} + (toPerformanceTiming self))) + +getDomContentLoadedEventStart :: + (MonadIO m, PerformanceTimingClass self) => self -> m Word64 +getDomContentLoadedEventStart self + = liftIO + (fromIntegral <$> + ({# call + webkit_dom_performance_timing_get_dom_content_loaded_event_start + #} + (toPerformanceTiming self))) + +getDomContentLoadedEventEnd :: + (MonadIO m, PerformanceTimingClass self) => self -> m Word64 +getDomContentLoadedEventEnd self + = liftIO + (fromIntegral <$> + ({# call + webkit_dom_performance_timing_get_dom_content_loaded_event_end + #} + (toPerformanceTiming self))) + +getDomComplete :: + (MonadIO m, PerformanceTimingClass self) => self -> m Word64 +getDomComplete self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_performance_timing_get_dom_complete #} + (toPerformanceTiming self))) + +getLoadEventStart :: + (MonadIO m, PerformanceTimingClass self) => self -> m Word64 +getLoadEventStart self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_performance_timing_get_load_event_start #} + (toPerformanceTiming self))) + +getLoadEventEnd :: + (MonadIO m, PerformanceTimingClass self) => self -> m Word64 +getLoadEventEnd self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_performance_timing_get_load_event_end #} + (toPerformanceTiming self))) +#endif diff --git a/Graphics/UI/Gtk/WebKit/DOM/Plugin.chs b/Graphics/UI/Gtk/WebKit/DOM/Plugin.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/Plugin.chs @@ -0,0 +1,78 @@ +module Graphics.UI.Gtk.WebKit.DOM.Plugin( +item, +namedItem, +getName, +getFilename, +getDescription, +getLength, +Plugin, +castToPlugin, +gTypePlugin, +PluginClass, +toPlugin, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures +import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + + +item :: + (MonadIO m, PluginClass self) => self -> Word -> m (Maybe MimeType) +item self index + = liftIO + (maybeNull (makeNewGObject mkMimeType) + ({# call webkit_dom_dom_plugin_item #} (toPlugin self) + (fromIntegral index))) + +namedItem :: + (MonadIO m, PluginClass self, GlibString string) => + self -> string -> m (Maybe MimeType) +namedItem self name + = liftIO + (maybeNull (makeNewGObject mkMimeType) + (withUTFString name $ + \ namePtr -> + {# call webkit_dom_dom_plugin_named_item #} (toPlugin self) + namePtr)) + +getName :: + (MonadIO m, PluginClass self, GlibString string) => + self -> m string +getName self + = liftIO + (({# call webkit_dom_dom_plugin_get_name #} (toPlugin self)) >>= + readUTFString) + +getFilename :: + (MonadIO m, PluginClass self, GlibString string) => + self -> m string +getFilename self + = liftIO + (({# call webkit_dom_dom_plugin_get_filename #} (toPlugin self)) + >>= + readUTFString) + +getDescription :: + (MonadIO m, PluginClass self, GlibString string) => + self -> m string +getDescription self + = liftIO + (({# call webkit_dom_dom_plugin_get_description #} (toPlugin self)) + >>= + readUTFString) + +getLength :: (MonadIO m, PluginClass self) => self -> m Word +getLength self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_dom_plugin_get_length #} (toPlugin self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/PluginArray.chs b/Graphics/UI/Gtk/WebKit/DOM/PluginArray.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/PluginArray.chs @@ -0,0 +1,61 @@ +module Graphics.UI.Gtk.WebKit.DOM.PluginArray( +item, +namedItem, +refresh, +getLength, +PluginArray, +castToPluginArray, +gTypePluginArray, +PluginArrayClass, +toPluginArray, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures +import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + + +item :: + (MonadIO m, PluginArrayClass self) => + self -> Word -> m (Maybe Plugin) +item self index + = liftIO + (maybeNull (makeNewGObject mkPlugin) + ({# call webkit_dom_dom_plugin_array_item #} (toPluginArray self) + (fromIntegral index))) + +namedItem :: + (MonadIO m, PluginArrayClass self, GlibString string) => + self -> string -> m (Maybe Plugin) +namedItem self name + = liftIO + (maybeNull (makeNewGObject mkPlugin) + (withUTFString name $ + \ namePtr -> + {# call webkit_dom_dom_plugin_array_named_item #} + (toPluginArray self) + namePtr)) + +refresh :: + (MonadIO m, PluginArrayClass self) => self -> Bool -> m () +refresh self reload + = liftIO + ({# call webkit_dom_dom_plugin_array_refresh #} + (toPluginArray self) + (fromBool reload)) + +getLength :: (MonadIO m, PluginArrayClass self) => self -> m Word +getLength self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_dom_plugin_array_get_length #} + (toPluginArray self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/ProcessingInstruction.chs b/Graphics/UI/Gtk/WebKit/DOM/ProcessingInstruction.chs --- a/Graphics/UI/Gtk/WebKit/DOM/ProcessingInstruction.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/ProcessingInstruction.chs @@ -1,48 +1,42 @@ -module Graphics.UI.Gtk.WebKit.DOM.ProcessingInstruction - (processingInstructionGetTarget, processingInstructionSetData, - processingInstructionGetData, processingInstructionGetSheet, - ProcessingInstruction, ProcessingInstructionClass, - castToProcessingInstruction, gTypeProcessingInstruction, - toProcessingInstruction) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.ProcessingInstruction( +getTarget, +getSheet, +ProcessingInstruction, +castToProcessingInstruction, +gTypeProcessingInstruction, +ProcessingInstructionClass, +toProcessingInstruction, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM - -processingInstructionGetTarget :: - (ProcessingInstructionClass self) => self -> IO String -processingInstructionGetTarget self - = ({# call webkit_dom_processing_instruction_get_target #} - (toProcessingInstruction self)) - >>= - readUTFString - -processingInstructionSetData :: - (ProcessingInstructionClass self) => self -> String -> IO () -processingInstructionSetData self val - = propagateGError $ - \ errorPtr_ -> - withUTFString val $ - \ valPtr -> - {# call webkit_dom_processing_instruction_set_data #} - (toProcessingInstruction self) - valPtr - errorPtr_ +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -processingInstructionGetData :: - (ProcessingInstructionClass self) => self -> IO String -processingInstructionGetData self - = ({# call webkit_dom_processing_instruction_get_data #} - (toProcessingInstruction self)) - >>= - readUTFString +getTarget :: + (MonadIO m, ProcessingInstructionClass self, GlibString string) => + self -> m (Maybe string) +getTarget self + = liftIO + (({# call webkit_dom_processing_instruction_get_target #} + (toProcessingInstruction self)) + >>= + maybePeek readUTFString) -processingInstructionGetSheet :: - (ProcessingInstructionClass self) => self -> IO (Maybe StyleSheet) -processingInstructionGetSheet self - = maybeNull (makeNewGObject mkStyleSheet) - ({# call webkit_dom_processing_instruction_get_sheet #} - (toProcessingInstruction self)) +getSheet :: + (MonadIO m, ProcessingInstructionClass self) => + self -> m (Maybe StyleSheet) +getSheet self + = liftIO + (maybeNull (makeNewGObject mkStyleSheet) + ({# call webkit_dom_processing_instruction_get_sheet #} + (toProcessingInstruction self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/Range.chs b/Graphics/UI/Gtk/WebKit/DOM/Range.chs --- a/Graphics/UI/Gtk/WebKit/DOM/Range.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/Range.chs @@ -1,327 +1,398 @@ -module Graphics.UI.Gtk.WebKit.DOM.Range - (rangeSetStart, rangeSetEnd, rangeSetStartBefore, - rangeSetStartAfter, rangeSetEndBefore, rangeSetEndAfter, - rangeCollapse, rangeSelectNode, rangeSelectNodeContents, - rangeCompareBoundaryPoints, rangeDeleteContents, - rangeExtractContents, rangeCloneContents, rangeInsertNode, - rangeSurroundContents, rangeCloneRange, rangeToString, rangeDetach, - rangeCreateContextualFragment, rangeIntersectsNode, - rangeCompareNode, rangeComparePoint, rangeIsPointInRange, - rangeExpand, cSTART_TO_START, cSTART_TO_END, cEND_TO_END, - cEND_TO_START, cNODE_BEFORE, cNODE_AFTER, cNODE_BEFORE_AND_AFTER, - cNODE_INSIDE, rangeGetStartContainer, rangeGetStartOffset, - rangeGetEndContainer, rangeGetEndOffset, rangeGetCollapsed, - rangeGetCommonAncestorContainer, rangeGetText, DOMRange, - DOMRangeClass, castToDOMRange, gTypeDOMRange, toDOMRange) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.Range( +setStart, +setEnd, +setStartBefore, +setStartAfter, +setEndBefore, +setEndAfter, +collapse, +selectNode, +selectNodeContents, +compareBoundaryPoints, +deleteContents, +extractContents, +cloneContents, +insertNode, +surroundContents, +cloneRange, +toString, +detach, +createContextualFragment, +intersectsNode, +compareNode, +comparePoint, +isPointInRange, +expand, +pattern START_TO_START, +pattern START_TO_END, +pattern END_TO_END, +pattern END_TO_START, +pattern NODE_BEFORE, +pattern NODE_AFTER, +pattern NODE_BEFORE_AND_AFTER, +pattern NODE_INSIDE, +getStartContainer, +getStartOffset, +getEndContainer, +getEndOffset, +getCollapsed, +getCommonAncestorContainer, +getText, +Range, +castToRange, +gTypeRange, +RangeClass, +toRange, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM - -rangeSetStart :: - (DOMRangeClass self, NodeClass refNode) => - self -> Maybe refNode -> Int -> IO () -rangeSetStart self refNode offset - = propagateGError $ - \ errorPtr_ -> - {# call webkit_dom_range_set_start #} (toDOMRange self) - (maybe (Node nullForeignPtr) toNode refNode) - (fromIntegral offset) - errorPtr_ - -rangeSetEnd :: - (DOMRangeClass self, NodeClass refNode) => - self -> Maybe refNode -> Int -> IO () -rangeSetEnd self refNode offset - = propagateGError $ - \ errorPtr_ -> - {# call webkit_dom_range_set_end #} (toDOMRange self) - (maybe (Node nullForeignPtr) toNode refNode) - (fromIntegral offset) - errorPtr_ - -rangeSetStartBefore :: - (DOMRangeClass self, NodeClass refNode) => - self -> Maybe refNode -> IO () -rangeSetStartBefore self refNode - = propagateGError $ - \ errorPtr_ -> - {# call webkit_dom_range_set_start_before #} (toDOMRange self) - (maybe (Node nullForeignPtr) toNode refNode) - errorPtr_ - -rangeSetStartAfter :: - (DOMRangeClass self, NodeClass refNode) => - self -> Maybe refNode -> IO () -rangeSetStartAfter self refNode - = propagateGError $ - \ errorPtr_ -> - {# call webkit_dom_range_set_start_after #} (toDOMRange self) - (maybe (Node nullForeignPtr) toNode refNode) - errorPtr_ - -rangeSetEndBefore :: - (DOMRangeClass self, NodeClass refNode) => - self -> Maybe refNode -> IO () -rangeSetEndBefore self refNode - = propagateGError $ - \ errorPtr_ -> - {# call webkit_dom_range_set_end_before #} (toDOMRange self) - (maybe (Node nullForeignPtr) toNode refNode) - errorPtr_ - -rangeSetEndAfter :: - (DOMRangeClass self, NodeClass refNode) => - self -> Maybe refNode -> IO () -rangeSetEndAfter self refNode - = propagateGError $ - \ errorPtr_ -> - {# call webkit_dom_range_set_end_after #} (toDOMRange self) - (maybe (Node nullForeignPtr) toNode refNode) - errorPtr_ - -rangeCollapse :: (DOMRangeClass self) => self -> Bool -> IO () -rangeCollapse self toStart - = propagateGError $ - \ errorPtr_ -> - {# call webkit_dom_range_collapse #} (toDOMRange self) - (fromBool toStart) - errorPtr_ - -rangeSelectNode :: - (DOMRangeClass self, NodeClass refNode) => - self -> Maybe refNode -> IO () -rangeSelectNode self refNode - = propagateGError $ - \ errorPtr_ -> - {# call webkit_dom_range_select_node #} (toDOMRange self) - (maybe (Node nullForeignPtr) toNode refNode) - errorPtr_ - -rangeSelectNodeContents :: - (DOMRangeClass self, NodeClass refNode) => - self -> Maybe refNode -> IO () -rangeSelectNodeContents self refNode - = propagateGError $ - \ errorPtr_ -> - {# call webkit_dom_range_select_node_contents #} (toDOMRange self) - (maybe (Node nullForeignPtr) toNode refNode) - errorPtr_ +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -rangeCompareBoundaryPoints :: - (DOMRangeClass self, DOMRangeClass sourceRange) => - self -> Word -> Maybe sourceRange -> IO Int -rangeCompareBoundaryPoints self how sourceRange - = fromIntegral <$> +setStart :: + (MonadIO m, RangeClass self, NodeClass refNode) => + self -> Maybe refNode -> Int -> m () +setStart self refNode offset + = liftIO (propagateGError $ \ errorPtr_ -> - {# call webkit_dom_range_compare_boundary_points #} - (toDOMRange self) - (fromIntegral how) - (maybe (DOMRange nullForeignPtr) toDOMRange sourceRange) + {# call webkit_dom_range_set_start #} (toRange self) + (maybe (Node nullForeignPtr) toNode refNode) + (fromIntegral offset) errorPtr_) -rangeDeleteContents :: (DOMRangeClass self) => self -> IO () -rangeDeleteContents self - = propagateGError $ - \ errorPtr_ -> - {# call webkit_dom_range_delete_contents #} (toDOMRange self) - errorPtr_ - -rangeExtractContents :: - (DOMRangeClass self) => self -> IO (Maybe DocumentFragment) -rangeExtractContents self - = maybeNull (makeNewGObject mkDocumentFragment) +setEnd :: + (MonadIO m, RangeClass self, NodeClass refNode) => + self -> Maybe refNode -> Int -> m () +setEnd self refNode offset + = liftIO (propagateGError $ \ errorPtr_ -> - {# call webkit_dom_range_extract_contents #} (toDOMRange self) + {# call webkit_dom_range_set_end #} (toRange self) + (maybe (Node nullForeignPtr) toNode refNode) + (fromIntegral offset) errorPtr_) -rangeCloneContents :: - (DOMRangeClass self) => self -> IO (Maybe DocumentFragment) -rangeCloneContents self - = maybeNull (makeNewGObject mkDocumentFragment) +setStartBefore :: + (MonadIO m, RangeClass self, NodeClass refNode) => + self -> Maybe refNode -> m () +setStartBefore self refNode + = liftIO (propagateGError $ \ errorPtr_ -> - {# call webkit_dom_range_clone_contents #} (toDOMRange self) + {# call webkit_dom_range_set_start_before #} (toRange self) + (maybe (Node nullForeignPtr) toNode refNode) errorPtr_) -rangeInsertNode :: - (DOMRangeClass self, NodeClass newNode) => - self -> Maybe newNode -> IO () -rangeInsertNode self newNode - = propagateGError $ - \ errorPtr_ -> - {# call webkit_dom_range_insert_node #} (toDOMRange self) - (maybe (Node nullForeignPtr) toNode newNode) - errorPtr_ - -rangeSurroundContents :: - (DOMRangeClass self, NodeClass newParent) => - self -> Maybe newParent -> IO () -rangeSurroundContents self newParent - = propagateGError $ - \ errorPtr_ -> - {# call webkit_dom_range_surround_contents #} (toDOMRange self) - (maybe (Node nullForeignPtr) toNode newParent) - errorPtr_ - -rangeCloneRange :: - (DOMRangeClass self) => self -> IO (Maybe DOMRange) -rangeCloneRange self - = maybeNull (makeNewGObject mkDOMRange) +setStartAfter :: + (MonadIO m, RangeClass self, NodeClass refNode) => + self -> Maybe refNode -> m () +setStartAfter self refNode + = liftIO (propagateGError $ \ errorPtr_ -> - {# call webkit_dom_range_clone_range #} (toDOMRange self) + {# call webkit_dom_range_set_start_after #} (toRange self) + (maybe (Node nullForeignPtr) toNode refNode) errorPtr_) -rangeToString :: (DOMRangeClass self) => self -> IO String -rangeToString self - = (propagateGError $ - \ errorPtr_ -> - {# call webkit_dom_range_to_string #} (toDOMRange self) errorPtr_) - >>= - readUTFString - -rangeDetach :: (DOMRangeClass self) => self -> IO () -rangeDetach self - = propagateGError $ - \ errorPtr_ -> - {# call webkit_dom_range_detach #} (toDOMRange self) errorPtr_ - -rangeCreateContextualFragment :: - (DOMRangeClass self) => - self -> String -> IO (Maybe DocumentFragment) -rangeCreateContextualFragment self html - = maybeNull (makeNewGObject mkDocumentFragment) +setEndBefore :: + (MonadIO m, RangeClass self, NodeClass refNode) => + self -> Maybe refNode -> m () +setEndBefore self refNode + = liftIO (propagateGError $ \ errorPtr_ -> - withUTFString html $ - \ htmlPtr -> - {# call webkit_dom_range_create_contextual_fragment #} - (toDOMRange self) - htmlPtr + {# call webkit_dom_range_set_end_before #} (toRange self) + (maybe (Node nullForeignPtr) toNode refNode) errorPtr_) -rangeIntersectsNode :: - (DOMRangeClass self, NodeClass refNode) => - self -> Maybe refNode -> IO Bool -rangeIntersectsNode self refNode - = toBool <$> +setEndAfter :: + (MonadIO m, RangeClass self, NodeClass refNode) => + self -> Maybe refNode -> m () +setEndAfter self refNode + = liftIO (propagateGError $ \ errorPtr_ -> - {# call webkit_dom_range_intersects_node #} (toDOMRange self) + {# call webkit_dom_range_set_end_after #} (toRange self) (maybe (Node nullForeignPtr) toNode refNode) errorPtr_) -rangeCompareNode :: - (DOMRangeClass self, NodeClass refNode) => - self -> Maybe refNode -> IO Int -rangeCompareNode self refNode - = fromIntegral <$> +collapse :: (MonadIO m, RangeClass self) => self -> Bool -> m () +collapse self toStart + = liftIO (propagateGError $ \ errorPtr_ -> - {# call webkit_dom_range_compare_node #} (toDOMRange self) - (maybe (Node nullForeignPtr) toNode refNode) + {# call webkit_dom_range_collapse #} (toRange self) + (fromBool toStart) errorPtr_) -rangeComparePoint :: - (DOMRangeClass self, NodeClass refNode) => - self -> Maybe refNode -> Int -> IO Int -rangeComparePoint self refNode offset - = fromIntegral <$> +selectNode :: + (MonadIO m, RangeClass self, NodeClass refNode) => + self -> Maybe refNode -> m () +selectNode self refNode + = liftIO (propagateGError $ \ errorPtr_ -> - {# call webkit_dom_range_compare_point #} (toDOMRange self) + {# call webkit_dom_range_select_node #} (toRange self) (maybe (Node nullForeignPtr) toNode refNode) - (fromIntegral offset) errorPtr_) -rangeIsPointInRange :: - (DOMRangeClass self, NodeClass refNode) => - self -> Maybe refNode -> Int -> IO Bool -rangeIsPointInRange self refNode offset - = toBool <$> +selectNodeContents :: + (MonadIO m, RangeClass self, NodeClass refNode) => + self -> Maybe refNode -> m () +selectNodeContents self refNode + = liftIO (propagateGError $ \ errorPtr_ -> - {# call webkit_dom_range_is_point_in_range #} (toDOMRange self) + {# call webkit_dom_range_select_node_contents #} (toRange self) (maybe (Node nullForeignPtr) toNode refNode) - (fromIntegral offset) errorPtr_) -rangeExpand :: (DOMRangeClass self) => self -> String -> IO () -rangeExpand self unit - = propagateGError $ - \ errorPtr_ -> - withUTFString unit $ - \ unitPtr -> - {# call webkit_dom_range_expand #} (toDOMRange self) unitPtr - errorPtr_ -cSTART_TO_START = 0 -cSTART_TO_END = 1 -cEND_TO_END = 2 -cEND_TO_START = 3 -cNODE_BEFORE = 0 -cNODE_AFTER = 1 -cNODE_BEFORE_AND_AFTER = 2 -cNODE_INSIDE = 3 +compareBoundaryPoints :: + (MonadIO m, RangeClass self, RangeClass sourceRange) => + self -> Word -> Maybe sourceRange -> m Int +compareBoundaryPoints self how sourceRange + = liftIO + (fromIntegral <$> + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_range_compare_boundary_points #} (toRange self) + (fromIntegral how) + (maybe (Range nullForeignPtr) toRange sourceRange) + errorPtr_)) -rangeGetStartContainer :: - (DOMRangeClass self) => self -> IO (Maybe Node) -rangeGetStartContainer self - = maybeNull (makeNewGObject mkNode) +deleteContents :: (MonadIO m, RangeClass self) => self -> m () +deleteContents self + = liftIO (propagateGError $ \ errorPtr_ -> - {# call webkit_dom_range_get_start_container #} (toDOMRange self) + {# call webkit_dom_range_delete_contents #} (toRange self) errorPtr_) -rangeGetStartOffset :: (DOMRangeClass self) => self -> IO Int -rangeGetStartOffset self - = fromIntegral <$> - (propagateGError $ - \ errorPtr_ -> - {# call webkit_dom_range_get_start_offset #} (toDOMRange self) - errorPtr_) +extractContents :: + (MonadIO m, RangeClass self) => self -> m (Maybe DocumentFragment) +extractContents self + = liftIO + (maybeNull (makeNewGObject mkDocumentFragment) + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_range_extract_contents #} (toRange self) + errorPtr_)) -rangeGetEndContainer :: - (DOMRangeClass self) => self -> IO (Maybe Node) -rangeGetEndContainer self - = maybeNull (makeNewGObject mkNode) +cloneContents :: + (MonadIO m, RangeClass self) => self -> m (Maybe DocumentFragment) +cloneContents self + = liftIO + (maybeNull (makeNewGObject mkDocumentFragment) + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_range_clone_contents #} (toRange self) + errorPtr_)) + +insertNode :: + (MonadIO m, RangeClass self, NodeClass newNode) => + self -> Maybe newNode -> m () +insertNode self newNode + = liftIO (propagateGError $ \ errorPtr_ -> - {# call webkit_dom_range_get_end_container #} (toDOMRange self) + {# call webkit_dom_range_insert_node #} (toRange self) + (maybe (Node nullForeignPtr) toNode newNode) errorPtr_) -rangeGetEndOffset :: (DOMRangeClass self) => self -> IO Int -rangeGetEndOffset self - = fromIntegral <$> +surroundContents :: + (MonadIO m, RangeClass self, NodeClass newParent) => + self -> Maybe newParent -> m () +surroundContents self newParent + = liftIO (propagateGError $ \ errorPtr_ -> - {# call webkit_dom_range_get_end_offset #} (toDOMRange self) + {# call webkit_dom_range_surround_contents #} (toRange self) + (maybe (Node nullForeignPtr) toNode newParent) errorPtr_) -rangeGetCollapsed :: (DOMRangeClass self) => self -> IO Bool -rangeGetCollapsed self - = toBool <$> +cloneRange :: + (MonadIO m, RangeClass self) => self -> m (Maybe Range) +cloneRange self + = liftIO + (maybeNull (makeNewGObject mkRange) + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_range_clone_range #} (toRange self) errorPtr_)) + +toString :: + (MonadIO m, RangeClass self, GlibString string) => self -> m string +toString self + = liftIO + ((propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_range_to_string #} (toRange self) errorPtr_) + >>= + readUTFString) + +detach :: (MonadIO m, RangeClass self) => self -> m () +detach self + = liftIO (propagateGError $ \ errorPtr_ -> - {# call webkit_dom_range_get_collapsed #} (toDOMRange self) - errorPtr_) + {# call webkit_dom_range_detach #} (toRange self) errorPtr_) -rangeGetCommonAncestorContainer :: - (DOMRangeClass self) => self -> IO (Maybe Node) -rangeGetCommonAncestorContainer self - = maybeNull (makeNewGObject mkNode) +createContextualFragment :: + (MonadIO m, RangeClass self, GlibString string) => + self -> string -> m (Maybe DocumentFragment) +createContextualFragment self html + = liftIO + (maybeNull (makeNewGObject mkDocumentFragment) + (propagateGError $ + \ errorPtr_ -> + withUTFString html $ + \ htmlPtr -> + {# call webkit_dom_range_create_contextual_fragment #} + (toRange self) + htmlPtr + errorPtr_)) + +intersectsNode :: + (MonadIO m, RangeClass self, NodeClass refNode) => + self -> Maybe refNode -> m Bool +intersectsNode self refNode + = liftIO + (toBool <$> + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_range_intersects_node #} (toRange self) + (maybe (Node nullForeignPtr) toNode refNode) + errorPtr_)) + +compareNode :: + (MonadIO m, RangeClass self, NodeClass refNode) => + self -> Maybe refNode -> m Int +compareNode self refNode + = liftIO + (fromIntegral <$> + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_range_compare_node #} (toRange self) + (maybe (Node nullForeignPtr) toNode refNode) + errorPtr_)) + +comparePoint :: + (MonadIO m, RangeClass self, NodeClass refNode) => + self -> Maybe refNode -> Int -> m Int +comparePoint self refNode offset + = liftIO + (fromIntegral <$> + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_range_compare_point #} (toRange self) + (maybe (Node nullForeignPtr) toNode refNode) + (fromIntegral offset) + errorPtr_)) + +isPointInRange :: + (MonadIO m, RangeClass self, NodeClass refNode) => + self -> Maybe refNode -> Int -> m Bool +isPointInRange self refNode offset + = liftIO + (toBool <$> + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_range_is_point_in_range #} (toRange self) + (maybe (Node nullForeignPtr) toNode refNode) + (fromIntegral offset) + errorPtr_)) + +expand :: + (MonadIO m, RangeClass self, GlibString string) => + self -> string -> m () +expand self unit + = liftIO (propagateGError $ \ errorPtr_ -> - {# call webkit_dom_range_get_common_ancestor_container #} - (toDOMRange self) + withUTFString unit $ + \ unitPtr -> + {# call webkit_dom_range_expand #} (toRange self) unitPtr errorPtr_) +pattern START_TO_START = 0 +pattern START_TO_END = 1 +pattern END_TO_END = 2 +pattern END_TO_START = 3 +pattern NODE_BEFORE = 0 +pattern NODE_AFTER = 1 +pattern NODE_BEFORE_AND_AFTER = 2 +pattern NODE_INSIDE = 3 -rangeGetText :: (DOMRangeClass self) => self -> IO String -rangeGetText self - = ({# call webkit_dom_range_get_text #} (toDOMRange self)) >>= - readUTFString +getStartContainer :: + (MonadIO m, RangeClass self) => self -> m (Maybe Node) +getStartContainer self + = liftIO + (maybeNull (makeNewGObject mkNode) + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_range_get_start_container #} (toRange self) + errorPtr_)) + +getStartOffset :: (MonadIO m, RangeClass self) => self -> m Int +getStartOffset self + = liftIO + (fromIntegral <$> + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_range_get_start_offset #} (toRange self) + errorPtr_)) + +getEndContainer :: + (MonadIO m, RangeClass self) => self -> m (Maybe Node) +getEndContainer self + = liftIO + (maybeNull (makeNewGObject mkNode) + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_range_get_end_container #} (toRange self) + errorPtr_)) + +getEndOffset :: (MonadIO m, RangeClass self) => self -> m Int +getEndOffset self + = liftIO + (fromIntegral <$> + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_range_get_end_offset #} (toRange self) + errorPtr_)) + +getCollapsed :: (MonadIO m, RangeClass self) => self -> m Bool +getCollapsed self + = liftIO + (toBool <$> + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_range_get_collapsed #} (toRange self) + errorPtr_)) + +getCommonAncestorContainer :: + (MonadIO m, RangeClass self) => self -> m (Maybe Node) +getCommonAncestorContainer self + = liftIO + (maybeNull (makeNewGObject mkNode) + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_range_get_common_ancestor_container #} + (toRange self) + errorPtr_)) + +getText :: + (MonadIO m, RangeClass self, GlibString string) => self -> m string +getText self + = liftIO + (({# call webkit_dom_range_get_text #} (toRange self)) >>= + readUTFString) diff --git a/Graphics/UI/Gtk/WebKit/DOM/Ranges.chs b/Graphics/UI/Gtk/WebKit/DOM/Ranges.chs deleted file mode 100644 --- a/Graphics/UI/Gtk/WebKit/DOM/Ranges.chs +++ /dev/null @@ -1,8 +0,0 @@ -module Graphics.UI.Gtk.WebKit.DOM.Ranges (DOMRange, DOMRangeClass) - where - -data DOMRange = DOMRange - -class DOMRangeClass a - -instance DOMRangeClass DOMRange diff --git a/Graphics/UI/Gtk/WebKit/DOM/Screen.chs b/Graphics/UI/Gtk/WebKit/DOM/Screen.chs --- a/Graphics/UI/Gtk/WebKit/DOM/Screen.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/Screen.chs @@ -1,52 +1,77 @@ -module Graphics.UI.Gtk.WebKit.DOM.Screen - (screenGetHeight, screenGetWidth, screenGetColorDepth, - screenGetPixelDepth, screenGetAvailLeft, screenGetAvailTop, - screenGetAvailHeight, screenGetAvailWidth, DOMScreen, - DOMScreenClass, castToDOMScreen, gTypeDOMScreen, toDOMScreen) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.Screen( +getHeight, +getWidth, +getColorDepth, +getPixelDepth, +getAvailLeft, +getAvailTop, +getAvailHeight, +getAvailWidth, +Screen, +castToScreen, +gTypeScreen, +ScreenClass, +toScreen, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -screenGetHeight :: (DOMScreenClass self) => self -> IO Word -screenGetHeight self - = fromIntegral <$> - ({# call webkit_dom_screen_get_height #} (toDOMScreen self)) +getHeight :: (MonadIO m, ScreenClass self) => self -> m Word +getHeight self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_screen_get_height #} (toScreen self))) -screenGetWidth :: (DOMScreenClass self) => self -> IO Word -screenGetWidth self - = fromIntegral <$> - ({# call webkit_dom_screen_get_width #} (toDOMScreen self)) +getWidth :: (MonadIO m, ScreenClass self) => self -> m Word +getWidth self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_screen_get_width #} (toScreen self))) -screenGetColorDepth :: (DOMScreenClass self) => self -> IO Word -screenGetColorDepth self - = fromIntegral <$> - ({# call webkit_dom_screen_get_color_depth #} (toDOMScreen self)) +getColorDepth :: (MonadIO m, ScreenClass self) => self -> m Word +getColorDepth self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_screen_get_color_depth #} (toScreen self))) -screenGetPixelDepth :: (DOMScreenClass self) => self -> IO Word -screenGetPixelDepth self - = fromIntegral <$> - ({# call webkit_dom_screen_get_pixel_depth #} (toDOMScreen self)) +getPixelDepth :: (MonadIO m, ScreenClass self) => self -> m Word +getPixelDepth self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_screen_get_pixel_depth #} (toScreen self))) -screenGetAvailLeft :: (DOMScreenClass self) => self -> IO Int -screenGetAvailLeft self - = fromIntegral <$> - ({# call webkit_dom_screen_get_avail_left #} (toDOMScreen self)) +getAvailLeft :: (MonadIO m, ScreenClass self) => self -> m Int +getAvailLeft self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_screen_get_avail_left #} (toScreen self))) -screenGetAvailTop :: (DOMScreenClass self) => self -> IO Int -screenGetAvailTop self - = fromIntegral <$> - ({# call webkit_dom_screen_get_avail_top #} (toDOMScreen self)) +getAvailTop :: (MonadIO m, ScreenClass self) => self -> m Int +getAvailTop self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_screen_get_avail_top #} (toScreen self))) -screenGetAvailHeight :: (DOMScreenClass self) => self -> IO Word -screenGetAvailHeight self - = fromIntegral <$> - ({# call webkit_dom_screen_get_avail_height #} (toDOMScreen self)) +getAvailHeight :: (MonadIO m, ScreenClass self) => self -> m Word +getAvailHeight self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_screen_get_avail_height #} (toScreen self))) -screenGetAvailWidth :: (DOMScreenClass self) => self -> IO Word -screenGetAvailWidth self - = fromIntegral <$> - ({# call webkit_dom_screen_get_avail_width #} (toDOMScreen self)) +getAvailWidth :: (MonadIO m, ScreenClass self) => self -> m Word +getAvailWidth self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_screen_get_avail_width #} (toScreen self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/SecurityPolicy.chs b/Graphics/UI/Gtk/WebKit/DOM/SecurityPolicy.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/SecurityPolicy.chs @@ -0,0 +1,201 @@ +module Graphics.UI.Gtk.WebKit.DOM.SecurityPolicy( +#if WEBKIT_CHECK_VERSION(2,2,2) +allowsConnectionTo, +allowsFontFrom, +allowsFormAction, +allowsFrameFrom, +allowsImageFrom, +allowsMediaFrom, +allowsObjectFrom, +allowsPluginType, +allowsScriptFrom, +allowsStyleFrom, +getAllowsEval, +getAllowsInlineScript, +getAllowsInlineStyle, +getIsActive, +getReportURIs, +SecurityPolicy, +castToSecurityPolicy, +gTypeSecurityPolicy, +SecurityPolicyClass, +toSecurityPolicy, +#endif +) where +#if WEBKIT_CHECK_VERSION(2,2,2) +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures +import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + + +allowsConnectionTo :: + (MonadIO m, SecurityPolicyClass self, GlibString string) => + self -> string -> m Bool +allowsConnectionTo self url + = liftIO + (toBool <$> + (withUTFString url $ + \ urlPtr -> + {# call webkit_dom_dom_security_policy_allows_connection_to #} + (toSecurityPolicy self) + urlPtr)) + +allowsFontFrom :: + (MonadIO m, SecurityPolicyClass self, GlibString string) => + self -> string -> m Bool +allowsFontFrom self url + = liftIO + (toBool <$> + (withUTFString url $ + \ urlPtr -> + {# call webkit_dom_dom_security_policy_allows_font_from #} + (toSecurityPolicy self) + urlPtr)) + +allowsFormAction :: + (MonadIO m, SecurityPolicyClass self, GlibString string) => + self -> string -> m Bool +allowsFormAction self url + = liftIO + (toBool <$> + (withUTFString url $ + \ urlPtr -> + {# call webkit_dom_dom_security_policy_allows_form_action #} + (toSecurityPolicy self) + urlPtr)) + +allowsFrameFrom :: + (MonadIO m, SecurityPolicyClass self, GlibString string) => + self -> string -> m Bool +allowsFrameFrom self url + = liftIO + (toBool <$> + (withUTFString url $ + \ urlPtr -> + {# call webkit_dom_dom_security_policy_allows_frame_from #} + (toSecurityPolicy self) + urlPtr)) + +allowsImageFrom :: + (MonadIO m, SecurityPolicyClass self, GlibString string) => + self -> string -> m Bool +allowsImageFrom self url + = liftIO + (toBool <$> + (withUTFString url $ + \ urlPtr -> + {# call webkit_dom_dom_security_policy_allows_image_from #} + (toSecurityPolicy self) + urlPtr)) + +allowsMediaFrom :: + (MonadIO m, SecurityPolicyClass self, GlibString string) => + self -> string -> m Bool +allowsMediaFrom self url + = liftIO + (toBool <$> + (withUTFString url $ + \ urlPtr -> + {# call webkit_dom_dom_security_policy_allows_media_from #} + (toSecurityPolicy self) + urlPtr)) + +allowsObjectFrom :: + (MonadIO m, SecurityPolicyClass self, GlibString string) => + self -> string -> m Bool +allowsObjectFrom self url + = liftIO + (toBool <$> + (withUTFString url $ + \ urlPtr -> + {# call webkit_dom_dom_security_policy_allows_object_from #} + (toSecurityPolicy self) + urlPtr)) + +allowsPluginType :: + (MonadIO m, SecurityPolicyClass self, GlibString string) => + self -> string -> m Bool +allowsPluginType self type' + = liftIO + (toBool <$> + (withUTFString type' $ + \ typePtr -> + {# call webkit_dom_dom_security_policy_allows_plugin_type #} + (toSecurityPolicy self) + typePtr)) + +allowsScriptFrom :: + (MonadIO m, SecurityPolicyClass self, GlibString string) => + self -> string -> m Bool +allowsScriptFrom self url + = liftIO + (toBool <$> + (withUTFString url $ + \ urlPtr -> + {# call webkit_dom_dom_security_policy_allows_script_from #} + (toSecurityPolicy self) + urlPtr)) + +allowsStyleFrom :: + (MonadIO m, SecurityPolicyClass self, GlibString string) => + self -> string -> m Bool +allowsStyleFrom self url + = liftIO + (toBool <$> + (withUTFString url $ + \ urlPtr -> + {# call webkit_dom_dom_security_policy_allows_style_from #} + (toSecurityPolicy self) + urlPtr)) + +getAllowsEval :: + (MonadIO m, SecurityPolicyClass self) => self -> m Bool +getAllowsEval self + = liftIO + (toBool <$> + ({# call webkit_dom_dom_security_policy_get_allows_eval #} + (toSecurityPolicy self))) + +getAllowsInlineScript :: + (MonadIO m, SecurityPolicyClass self) => self -> m Bool +getAllowsInlineScript self + = liftIO + (toBool <$> + ({# call webkit_dom_dom_security_policy_get_allows_inline_script #} + (toSecurityPolicy self))) + +getAllowsInlineStyle :: + (MonadIO m, SecurityPolicyClass self) => self -> m Bool +getAllowsInlineStyle self + = liftIO + (toBool <$> + ({# call webkit_dom_dom_security_policy_get_allows_inline_style #} + (toSecurityPolicy self))) + +getIsActive :: + (MonadIO m, SecurityPolicyClass self) => self -> m Bool +getIsActive self + = liftIO + (toBool <$> + ({# call webkit_dom_dom_security_policy_get_is_active #} + (toSecurityPolicy self))) + +getReportURIs :: + (MonadIO m, SecurityPolicyClass self) => + self -> m (Maybe DOMStringList) +getReportURIs self + = liftIO + (maybeNull (makeNewGObject mkDOMStringList) + ({# call webkit_dom_dom_security_policy_get_report_ur_is #} + (toSecurityPolicy self))) +#endif diff --git a/Graphics/UI/Gtk/WebKit/DOM/Selection.chs b/Graphics/UI/Gtk/WebKit/DOM/Selection.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/Selection.chs @@ -0,0 +1,268 @@ +module Graphics.UI.Gtk.WebKit.DOM.Selection( +collapse, +collapseToEnd, +collapseToStart, +deleteFromDocument, +containsNode, +selectAllChildren, +extend, +getRangeAt, +removeAllRanges, +addRange, +modify, +setBaseAndExtent, +setPosition, +empty, +getAnchorNode, +getAnchorOffset, +getFocusNode, +getFocusOffset, +getIsCollapsed, +getRangeCount, +getBaseNode, +getBaseOffset, +getExtentNode, +getExtentOffset, +Selection, +castToSelection, +gTypeSelection, +SelectionClass, +toSelection, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures +import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + + +collapse :: + (MonadIO m, SelectionClass self, NodeClass node) => + self -> Maybe node -> Int -> m () +collapse self node index + = liftIO + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_dom_selection_collapse #} (toSelection self) + (maybe (Node nullForeignPtr) toNode node) + (fromIntegral index) + errorPtr_) + +collapseToEnd :: (MonadIO m, SelectionClass self) => self -> m () +collapseToEnd self + = liftIO + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_dom_selection_collapse_to_end #} + (toSelection self) + errorPtr_) + +collapseToStart :: (MonadIO m, SelectionClass self) => self -> m () +collapseToStart self + = liftIO + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_dom_selection_collapse_to_start #} + (toSelection self) + errorPtr_) + +deleteFromDocument :: + (MonadIO m, SelectionClass self) => self -> m () +deleteFromDocument self + = liftIO + ({# call webkit_dom_dom_selection_delete_from_document #} + (toSelection self)) + +containsNode :: + (MonadIO m, SelectionClass self, NodeClass node) => + self -> Maybe node -> Bool -> m Bool +containsNode self node allowPartial + = liftIO + (toBool <$> + ({# call webkit_dom_dom_selection_contains_node #} + (toSelection self) + (maybe (Node nullForeignPtr) toNode node) + (fromBool allowPartial))) + +selectAllChildren :: + (MonadIO m, SelectionClass self, NodeClass node) => + self -> Maybe node -> m () +selectAllChildren self node + = liftIO + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_dom_selection_select_all_children #} + (toSelection self) + (maybe (Node nullForeignPtr) toNode node) + errorPtr_) + +extend :: + (MonadIO m, SelectionClass self, NodeClass node) => + self -> Maybe node -> Int -> m () +extend self node offset + = liftIO + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_dom_selection_extend #} (toSelection self) + (maybe (Node nullForeignPtr) toNode node) + (fromIntegral offset) + errorPtr_) + +getRangeAt :: + (MonadIO m, SelectionClass self) => self -> Int -> m (Maybe Range) +getRangeAt self index + = liftIO + (maybeNull (makeNewGObject mkRange) + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_dom_selection_get_range_at #} (toSelection self) + (fromIntegral index) + errorPtr_)) + +removeAllRanges :: (MonadIO m, SelectionClass self) => self -> m () +removeAllRanges self + = liftIO + ({# call webkit_dom_dom_selection_remove_all_ranges #} + (toSelection self)) + +addRange :: + (MonadIO m, SelectionClass self, RangeClass range) => + self -> Maybe range -> m () +addRange self range + = liftIO + ({# call webkit_dom_dom_selection_add_range #} (toSelection self) + (maybe (Range nullForeignPtr) toRange range)) + +modify :: + (MonadIO m, SelectionClass self, GlibString string) => + self -> string -> string -> string -> m () +modify self alter direction granularity + = liftIO + (withUTFString granularity $ + \ granularityPtr -> + withUTFString direction $ + \ directionPtr -> + withUTFString alter $ + \ alterPtr -> + {# call webkit_dom_dom_selection_modify #} (toSelection self) + alterPtr + directionPtr + granularityPtr) + +setBaseAndExtent :: + (MonadIO m, SelectionClass self, NodeClass baseNode, + NodeClass extentNode) => + self -> Maybe baseNode -> Int -> Maybe extentNode -> Int -> m () +setBaseAndExtent self baseNode baseOffset extentNode extentOffset + = liftIO + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_dom_selection_set_base_and_extent #} + (toSelection self) + (maybe (Node nullForeignPtr) toNode baseNode) + (fromIntegral baseOffset) + (maybe (Node nullForeignPtr) toNode extentNode) + (fromIntegral extentOffset) + errorPtr_) + +setPosition :: + (MonadIO m, SelectionClass self, NodeClass node) => + self -> Maybe node -> Int -> m () +setPosition self node offset + = liftIO + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_dom_selection_set_position #} (toSelection self) + (maybe (Node nullForeignPtr) toNode node) + (fromIntegral offset) + errorPtr_) + +empty :: (MonadIO m, SelectionClass self) => self -> m () +empty self + = liftIO + ({# call webkit_dom_dom_selection_empty #} (toSelection self)) + +getAnchorNode :: + (MonadIO m, SelectionClass self) => self -> m (Maybe Node) +getAnchorNode self + = liftIO + (maybeNull (makeNewGObject mkNode) + ({# call webkit_dom_dom_selection_get_anchor_node #} + (toSelection self))) + +getAnchorOffset :: + (MonadIO m, SelectionClass self) => self -> m Int +getAnchorOffset self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_dom_selection_get_anchor_offset #} + (toSelection self))) + +getFocusNode :: + (MonadIO m, SelectionClass self) => self -> m (Maybe Node) +getFocusNode self + = liftIO + (maybeNull (makeNewGObject mkNode) + ({# call webkit_dom_dom_selection_get_focus_node #} + (toSelection self))) + +getFocusOffset :: (MonadIO m, SelectionClass self) => self -> m Int +getFocusOffset self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_dom_selection_get_focus_offset #} + (toSelection self))) + +getIsCollapsed :: + (MonadIO m, SelectionClass self) => self -> m Bool +getIsCollapsed self + = liftIO + (toBool <$> + ({# call webkit_dom_dom_selection_get_is_collapsed #} + (toSelection self))) + +getRangeCount :: (MonadIO m, SelectionClass self) => self -> m Int +getRangeCount self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_dom_selection_get_range_count #} + (toSelection self))) + +getBaseNode :: + (MonadIO m, SelectionClass self) => self -> m (Maybe Node) +getBaseNode self + = liftIO + (maybeNull (makeNewGObject mkNode) + ({# call webkit_dom_dom_selection_get_base_node #} + (toSelection self))) + +getBaseOffset :: (MonadIO m, SelectionClass self) => self -> m Int +getBaseOffset self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_dom_selection_get_base_offset #} + (toSelection self))) + +getExtentNode :: + (MonadIO m, SelectionClass self) => self -> m (Maybe Node) +getExtentNode self + = liftIO + (maybeNull (makeNewGObject mkNode) + ({# call webkit_dom_dom_selection_get_extent_node #} + (toSelection self))) + +getExtentOffset :: + (MonadIO m, SelectionClass self) => self -> m Int +getExtentOffset self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_dom_selection_get_extent_offset #} + (toSelection self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/Storage.chs b/Graphics/UI/Gtk/WebKit/DOM/Storage.chs --- a/Graphics/UI/Gtk/WebKit/DOM/Storage.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/Storage.chs @@ -1,74 +1,105 @@ -module Graphics.UI.Gtk.WebKit.DOM.Storage - (storageKey, storageGetItem, storageSetItem, storageRemoveItem, - storageClear, storageGetLength, Storage, StorageClass, - castToStorage, gTypeStorage, toStorage) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} -import System.Glib.GError -import Graphics.UI.Gtk.WebKit.DOM.EventM - - -storageKey :: (StorageClass self) => self -> Word -> IO String -#if WEBKIT_CHECK_VERSION(2,0,0) -storageKey self index = propagateGError $ \errorPtr -> - ({# call webkit_dom_storage_key #} (toStorage self) (fromIntegral index) errorPtr >>= readUTFString) -#else -storageKey self index = {# call webkit_dom_storage_key #} (toStorage self) (fromIntegral index) >>= readUTFString +module Graphics.UI.Gtk.WebKit.DOM.Storage( +#if WEBKIT_CHECK_VERSION(2,2,2) +key, +getItem, #endif - - -storageGetItem :: (StorageClass self) => self -> String -> IO String -#if WEBKIT_CHECK_VERSION(2,0,0) -storageGetItem self key = propagateGError $ \errorPtr -> ( - (withUTFString key $ \keyPtr -> - {# call webkit_dom_storage_get_item #} (toStorage self) keyPtr errorPtr) - >>= readUTFString) -#else -storageGetItem self key = - (withUTFString key $ \keyPtr -> - {# call webkit_dom_storage_get_item #} (toStorage self) keyPtr) - >>= readUTFString +setItem, +#if WEBKIT_CHECK_VERSION(2,2,2) +removeItem, +clear, +getLength, #endif +Storage, +castToStorage, +gTypeStorage, +StorageClass, +toStorage, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures +import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums -storageSetItem :: (StorageClass self) => self -> String -> String -> IO () -storageSetItem self key data' - = propagateGError $ - \ errorPtr_ -> - withUTFString data' $ - \ dataPtr -> +#if WEBKIT_CHECK_VERSION(2,2,2) +key :: + (MonadIO m, StorageClass self, GlibString string) => + self -> Word -> m (Maybe string) +key self index + = liftIO + ((propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_storage_key #} (toStorage self) + (fromIntegral index) + errorPtr_) + >>= + maybePeek readUTFString) + +getItem :: + (MonadIO m, StorageClass self, GlibString string) => + self -> string -> m (Maybe string) +getItem self key + = liftIO + ((propagateGError $ + \ errorPtr_ -> withUTFString key $ \ keyPtr -> - {# call webkit_dom_storage_set_item #} (toStorage self) keyPtr - dataPtr - errorPtr_ - - -storageRemoveItem :: (StorageClass self) => self -> String -> IO () -#if WEBKIT_CHECK_VERSION(2,0,0) -storageRemoveItem self key = propagateGError $ \errorPtr -> ( - withUTFString key $ \keyPtr -> - {# call webkit_dom_storage_remove_item #} (toStorage self) keyPtr errorPtr) -#else -storageRemoveItem self key = withUTFString key $ \keyPtr -> - {# call webkit_dom_storage_remove_item #} (toStorage self) keyPtr -#endif - - -storageClear :: (StorageClass self) => self -> IO () -#if WEBKIT_CHECK_VERSION(2,0,0) -storageClear self = propagateGError $ {# call webkit_dom_storage_clear #} (toStorage self) -#else -storageClear = {# call webkit_dom_storage_clear #} . toStorage + {# call webkit_dom_storage_get_item #} (toStorage self) keyPtr + errorPtr_) + >>= + maybePeek readUTFString) #endif - + +setItem :: + (MonadIO m, StorageClass self, GlibString string) => + self -> string -> string -> m () +setItem self key data' + = liftIO + (propagateGError $ + \ errorPtr_ -> + withUTFString data' $ + \ dataPtr -> + withUTFString key $ + \ keyPtr -> + {# call webkit_dom_storage_set_item #} (toStorage self) keyPtr + dataPtr + errorPtr_) -storageGetLength :: (StorageClass self) => self -> IO Word -#if WEBKIT_CHECK_VERSION(2,0,0) -storageGetLength self = fromIntegral <$> propagateGError ({# call webkit_dom_storage_get_length #} (toStorage self)) -#else -storageGetLength self = fromIntegral <$> ({# call webkit_dom_storage_get_length #} (toStorage self)) +#if WEBKIT_CHECK_VERSION(2,2,2) +removeItem :: + (MonadIO m, StorageClass self, GlibString string) => + self -> string -> m () +removeItem self key + = liftIO + (propagateGError $ + \ errorPtr_ -> + withUTFString key $ + \ keyPtr -> + {# call webkit_dom_storage_remove_item #} (toStorage self) keyPtr + errorPtr_) + +clear :: (MonadIO m, StorageClass self) => self -> m () +clear self + = liftIO + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_storage_clear #} (toStorage self) errorPtr_) + +getLength :: (MonadIO m, StorageClass self) => self -> m Word +getLength self + = liftIO + (fromIntegral <$> + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_storage_get_length #} (toStorage self) + errorPtr_)) #endif diff --git a/Graphics/UI/Gtk/WebKit/DOM/StorageInfo.chs b/Graphics/UI/Gtk/WebKit/DOM/StorageInfo.chs --- a/Graphics/UI/Gtk/WebKit/DOM/StorageInfo.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/StorageInfo.chs @@ -1,15 +1,29 @@ -module Graphics.UI.Gtk.WebKit.DOM.StorageInfo - ( -#if WEBKIT_CHECK_VERSION(1,10,0) - cTEMPORARY, cPERSISTENT, StorageInfo, StorageInfoClass, - castToStorageInfo, gTypeStorageInfo, toStorageInfo +module Graphics.UI.Gtk.WebKit.DOM.StorageInfo( +#if WEBKIT_CHECK_VERSION(2,2,2) +pattern TEMPORARY, +pattern PERSISTENT, +StorageInfo, +castToStorageInfo, +gTypeStorageInfo, +StorageInfoClass, +toStorageInfo, #endif - ) where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +) where +#if WEBKIT_CHECK_VERSION(2,2,2) +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM -cTEMPORARY = 0 -cPERSISTENT = 1 +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + +pattern TEMPORARY = 0 +pattern PERSISTENT = 1 +#endif diff --git a/Graphics/UI/Gtk/WebKit/DOM/StyleMedia.chs b/Graphics/UI/Gtk/WebKit/DOM/StyleMedia.chs --- a/Graphics/UI/Gtk/WebKit/DOM/StyleMedia.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/StyleMedia.chs @@ -1,19 +1,33 @@ -module Graphics.UI.Gtk.WebKit.DOM.StyleMedia - (styleMediaMatchMedium, StyleMedia, StyleMediaClass, - castToStyleMedia, gTypeStyleMedia, toStyleMedia) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.StyleMedia( +matchMedium, +StyleMedia, +castToStyleMedia, +gTypeStyleMedia, +StyleMediaClass, +toStyleMedia, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -styleMediaMatchMedium :: - (StyleMediaClass self) => self -> String -> IO Bool -styleMediaMatchMedium self mediaquery - = toBool <$> - (withUTFString mediaquery $ - \ mediaqueryPtr -> - {# call webkit_dom_style_media_match_medium #} (toStyleMedia self) - mediaqueryPtr) +matchMedium :: + (MonadIO m, StyleMediaClass self, GlibString string) => + self -> string -> m Bool +matchMedium self mediaquery + = liftIO + (toBool <$> + (withUTFString mediaquery $ + \ mediaqueryPtr -> + {# call webkit_dom_style_media_match_medium #} (toStyleMedia self) + mediaqueryPtr)) diff --git a/Graphics/UI/Gtk/WebKit/DOM/StyleSheet.chs b/Graphics/UI/Gtk/WebKit/DOM/StyleSheet.chs --- a/Graphics/UI/Gtk/WebKit/DOM/StyleSheet.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/StyleSheet.chs @@ -1,58 +1,83 @@ -module Graphics.UI.Gtk.WebKit.DOM.StyleSheet - (styleSheetSetDisabled, styleSheetGetDisabled, - styleSheetGetOwnerNode, styleSheetGetParentStyleSheet, - styleSheetGetHref, styleSheetGetTitle, styleSheetGetMedia, - StyleSheet, StyleSheetClass, castToStyleSheet, gTypeStyleSheet, - toStyleSheet) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.StyleSheet( +setDisabled, +getDisabled, +getOwnerNode, +getParentStyleSheet, +getHref, +getTitle, +getMedia, +StyleSheet, +castToStyleSheet, +gTypeStyleSheet, +StyleSheetClass, +toStyleSheet, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -styleSheetSetDisabled :: - (StyleSheetClass self) => self -> Bool -> IO () -styleSheetSetDisabled self val - = {# call webkit_dom_style_sheet_set_disabled #} - (toStyleSheet self) - (fromBool val) +setDisabled :: + (MonadIO m, StyleSheetClass self) => self -> Bool -> m () +setDisabled self val + = liftIO + ({# call webkit_dom_style_sheet_set_disabled #} (toStyleSheet self) + (fromBool val)) -styleSheetGetDisabled :: (StyleSheetClass self) => self -> IO Bool -styleSheetGetDisabled self - = toBool <$> - ({# call webkit_dom_style_sheet_get_disabled #} - (toStyleSheet self)) +getDisabled :: (MonadIO m, StyleSheetClass self) => self -> m Bool +getDisabled self + = liftIO + (toBool <$> + ({# call webkit_dom_style_sheet_get_disabled #} + (toStyleSheet self))) -styleSheetGetOwnerNode :: - (StyleSheetClass self) => self -> IO (Maybe Node) -styleSheetGetOwnerNode self - = maybeNull (makeNewGObject mkNode) - ({# call webkit_dom_style_sheet_get_owner_node #} - (toStyleSheet self)) +getOwnerNode :: + (MonadIO m, StyleSheetClass self) => self -> m (Maybe Node) +getOwnerNode self + = liftIO + (maybeNull (makeNewGObject mkNode) + ({# call webkit_dom_style_sheet_get_owner_node #} + (toStyleSheet self))) -styleSheetGetParentStyleSheet :: - (StyleSheetClass self) => self -> IO (Maybe StyleSheet) -styleSheetGetParentStyleSheet self - = maybeNull (makeNewGObject mkStyleSheet) - ({# call webkit_dom_style_sheet_get_parent_style_sheet #} - (toStyleSheet self)) +getParentStyleSheet :: + (MonadIO m, StyleSheetClass self) => self -> m (Maybe StyleSheet) +getParentStyleSheet self + = liftIO + (maybeNull (makeNewGObject mkStyleSheet) + ({# call webkit_dom_style_sheet_get_parent_style_sheet #} + (toStyleSheet self))) -styleSheetGetHref :: (StyleSheetClass self) => self -> IO String -styleSheetGetHref self - = ({# call webkit_dom_style_sheet_get_href #} (toStyleSheet self)) - >>= - readUTFString +getHref :: + (MonadIO m, StyleSheetClass self, GlibString string) => + self -> m (Maybe string) +getHref self + = liftIO + (({# call webkit_dom_style_sheet_get_href #} (toStyleSheet self)) + >>= + maybePeek readUTFString) -styleSheetGetTitle :: (StyleSheetClass self) => self -> IO String -styleSheetGetTitle self - = ({# call webkit_dom_style_sheet_get_title #} (toStyleSheet self)) - >>= - readUTFString +getTitle :: + (MonadIO m, StyleSheetClass self, GlibString string) => + self -> m (Maybe string) +getTitle self + = liftIO + (({# call webkit_dom_style_sheet_get_title #} (toStyleSheet self)) + >>= + maybePeek readUTFString) -styleSheetGetMedia :: - (StyleSheetClass self) => self -> IO (Maybe MediaList) -styleSheetGetMedia self - = maybeNull (makeNewGObject mkMediaList) - ({# call webkit_dom_style_sheet_get_media #} (toStyleSheet self)) +getMedia :: + (MonadIO m, StyleSheetClass self) => self -> m (Maybe MediaList) +getMedia self + = liftIO + (maybeNull (makeNewGObject mkMediaList) + ({# call webkit_dom_style_sheet_get_media #} (toStyleSheet self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/StyleSheetList.chs b/Graphics/UI/Gtk/WebKit/DOM/StyleSheetList.chs --- a/Graphics/UI/Gtk/WebKit/DOM/StyleSheetList.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/StyleSheetList.chs @@ -1,26 +1,41 @@ -module Graphics.UI.Gtk.WebKit.DOM.StyleSheetList - (styleSheetListItem, styleSheetListGetLength, StyleSheetList, - StyleSheetListClass, castToStyleSheetList, gTypeStyleSheetList, - toStyleSheetList) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.StyleSheetList( +item, +getLength, +StyleSheetList, +castToStyleSheetList, +gTypeStyleSheetList, +StyleSheetListClass, +toStyleSheetList, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -styleSheetListItem :: - (StyleSheetListClass self) => self -> Word -> IO (Maybe StyleSheet) -styleSheetListItem self index - = maybeNull (makeNewGObject mkStyleSheet) - ({# call webkit_dom_style_sheet_list_item #} - (toStyleSheetList self) - (fromIntegral index)) +item :: + (MonadIO m, StyleSheetListClass self) => + self -> Word -> m (Maybe StyleSheet) +item self index + = liftIO + (maybeNull (makeNewGObject mkStyleSheet) + ({# call webkit_dom_style_sheet_list_item #} + (toStyleSheetList self) + (fromIntegral index))) -styleSheetListGetLength :: - (StyleSheetListClass self) => self -> IO Word -styleSheetListGetLength self - = fromIntegral <$> - ({# call webkit_dom_style_sheet_list_get_length #} - (toStyleSheetList self)) +getLength :: + (MonadIO m, StyleSheetListClass self) => self -> m Word +getLength self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_style_sheet_list_get_length #} + (toStyleSheetList self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/Stylesheets.chs b/Graphics/UI/Gtk/WebKit/DOM/Stylesheets.chs deleted file mode 100644 --- a/Graphics/UI/Gtk/WebKit/DOM/Stylesheets.chs +++ /dev/null @@ -1,8 +0,0 @@ -module Graphics.UI.Gtk.WebKit.DOM.Stylesheets - (MediaList, MediaListClass) where - -data MediaList = MediaList - -class MediaListClass a - -instance MediaListClass MediaList diff --git a/Graphics/UI/Gtk/WebKit/DOM/Text.chs b/Graphics/UI/Gtk/WebKit/DOM/Text.chs --- a/Graphics/UI/Gtk/WebKit/DOM/Text.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/Text.chs @@ -1,37 +1,56 @@ -module Graphics.UI.Gtk.WebKit.DOM.Text - (textSplitText, textReplaceWholeText, textGetWholeText, Text(..), - TextClass(..), castToText, gTypeText, toText) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.Text( +splitText, +replaceWholeText, +getWholeText, +Text, +castToText, +gTypeText, +TextClass, +toText, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -textSplitText :: - (TextClass self) => self -> Word -> IO (Maybe Text) -textSplitText self offset - = maybeNull (makeNewGObject mkText) - (propagateGError $ - \ errorPtr_ -> - {# call webkit_dom_text_split_text #} (toText self) - (fromIntegral offset) - errorPtr_) +splitText :: + (MonadIO m, TextClass self) => self -> Word -> m (Maybe Text) +splitText self offset + = liftIO + (maybeNull (makeNewGObject mkText) + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_text_split_text #} (toText self) + (fromIntegral offset) + errorPtr_)) -textReplaceWholeText :: - (TextClass self) => self -> String -> IO (Maybe Text) -textReplaceWholeText self content - = maybeNull (makeNewGObject mkText) - (propagateGError $ - \ errorPtr_ -> - withUTFString content $ - \ contentPtr -> - {# call webkit_dom_text_replace_whole_text #} (toText self) - contentPtr - errorPtr_) +replaceWholeText :: + (MonadIO m, TextClass self, GlibString string) => + self -> string -> m (Maybe Text) +replaceWholeText self content + = liftIO + (maybeNull (makeNewGObject mkText) + (propagateGError $ + \ errorPtr_ -> + withUTFString content $ + \ contentPtr -> + {# call webkit_dom_text_replace_whole_text #} (toText self) + contentPtr + errorPtr_)) -textGetWholeText :: (TextClass self) => self -> IO String -textGetWholeText self - = ({# call webkit_dom_text_get_whole_text #} (toText self)) >>= - readUTFString +getWholeText :: + (MonadIO m, TextClass self, GlibString string) => self -> m string +getWholeText self + = liftIO + (({# call webkit_dom_text_get_whole_text #} (toText self)) >>= + readUTFString) diff --git a/Graphics/UI/Gtk/WebKit/DOM/TextTrack.chs b/Graphics/UI/Gtk/WebKit/DOM/TextTrack.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/TextTrack.chs @@ -0,0 +1,136 @@ +module Graphics.UI.Gtk.WebKit.DOM.TextTrack( +#if WEBKIT_CHECK_VERSION(2,2,2) +#if WEBKIT_CHECK_VERSION(2,7,0) +addCue, +#endif +removeCue, +#if WEBKIT_CHECK_VERSION(2,4,0) +getId, +#endif +getLabel, +#if WEBKIT_CHECK_VERSION(99,0,0) +getInBandMetadataTrackDispatchType, +#endif +setMode, +getMode, +getCues, +getActiveCues, +cueChange, +TextTrack, +castToTextTrack, +gTypeTextTrack, +TextTrackClass, +toTextTrack, +#endif +) where +#if WEBKIT_CHECK_VERSION(2,2,2) +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures +import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + + +#if WEBKIT_CHECK_VERSION(2,7,0) +addCue :: + (MonadIO m, TextTrackClass self, TextTrackCueClass cue) => + self -> Maybe cue -> m () +addCue self cue + = liftIO + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_webkit_dom_text_track_add_cue_with_error #} + (toTextTrack self) + (maybe (TextTrackCue nullForeignPtr) toTextTrackCue cue) + errorPtr_) +#endif + +removeCue :: + (MonadIO m, TextTrackClass self, TextTrackCueClass cue) => + self -> Maybe cue -> m () +removeCue self cue + = liftIO + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_text_track_remove_cue #} (toTextTrack self) + (maybe (TextTrackCue nullForeignPtr) toTextTrackCue cue) + errorPtr_) + +#if WEBKIT_CHECK_VERSION(2,4,0) +getId :: + (MonadIO m, TextTrackClass self, GlibString string) => + self -> m string +getId self + = liftIO + (({# call webkit_dom_text_track_get_id #} (toTextTrack self)) >>= + readUTFString) +#endif + +getLabel :: + (MonadIO m, TextTrackClass self, GlibString string) => + self -> m string +getLabel self + = liftIO + (({# call webkit_dom_text_track_get_label #} (toTextTrack self)) + >>= + readUTFString) + +#if WEBKIT_CHECK_VERSION(99,0,0) +getInBandMetadataTrackDispatchType :: + (MonadIO m, TextTrackClass self, GlibString string) => + self -> m string +getInBandMetadataTrackDispatchType self + = liftIO + (({# call + webkit_dom_text_track_get_in_band_metadata_track_dispatch_type + #} + (toTextTrack self)) + >>= + readUTFString) +#endif + +setMode :: + (MonadIO m, TextTrackClass self) => self -> TextTrackMode -> m () +setMode self val + = liftIO + (withUTFString (enumToString val) $ + \ valPtr -> + {# call webkit_dom_text_track_set_mode #} (toTextTrack self) + valPtr) + +getMode :: + (MonadIO m, TextTrackClass self) => self -> m TextTrackMode +getMode self + = liftIO + (stringToEnum <$> + (({# call webkit_dom_text_track_get_mode #} (toTextTrack self)) >>= + readUTFString)) + +getCues :: + (MonadIO m, TextTrackClass self) => + self -> m (Maybe TextTrackCueList) +getCues self + = liftIO + (maybeNull (makeNewGObject mkTextTrackCueList) + ({# call webkit_dom_text_track_get_cues #} (toTextTrack self))) + +getActiveCues :: + (MonadIO m, TextTrackClass self) => + self -> m (Maybe TextTrackCueList) +getActiveCues self + = liftIO + (maybeNull (makeNewGObject mkTextTrackCueList) + ({# call webkit_dom_text_track_get_active_cues #} + (toTextTrack self))) + +cueChange :: (TextTrackClass self) => EventName self Event +cueChange = EventName "cuechange" +#endif diff --git a/Graphics/UI/Gtk/WebKit/DOM/TextTrackCue.chs b/Graphics/UI/Gtk/WebKit/DOM/TextTrackCue.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/TextTrackCue.chs @@ -0,0 +1,124 @@ +module Graphics.UI.Gtk.WebKit.DOM.TextTrackCue( +#if WEBKIT_CHECK_VERSION(2,2,2) +getTrack, +setId, +getId, +setStartTime, +getStartTime, +setEndTime, +getEndTime, +setPauseOnExit, +getPauseOnExit, +enter, +exit, +TextTrackCue, +castToTextTrackCue, +gTypeTextTrackCue, +TextTrackCueClass, +toTextTrackCue, +#endif +) where +#if WEBKIT_CHECK_VERSION(2,2,2) +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures +import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + + +getTrack :: + (MonadIO m, TextTrackCueClass self) => self -> m (Maybe TextTrack) +getTrack self + = liftIO + (maybeNull (makeNewGObject mkTextTrack) + ({# call webkit_dom_text_track_cue_get_track #} + (toTextTrackCue self))) + +setId :: + (MonadIO m, TextTrackCueClass self, GlibString string) => + self -> string -> m () +setId self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_text_track_cue_set_id #} (toTextTrackCue self) + valPtr) + +getId :: + (MonadIO m, TextTrackCueClass self, GlibString string) => + self -> m string +getId self + = liftIO + (({# call webkit_dom_text_track_cue_get_id #} + (toTextTrackCue self)) + >>= + readUTFString) + +setStartTime :: + (MonadIO m, TextTrackCueClass self) => self -> Double -> m () +setStartTime self val + = liftIO + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_text_track_cue_set_start_time #} + (toTextTrackCue self) + (realToFrac val) + errorPtr_) + +getStartTime :: + (MonadIO m, TextTrackCueClass self) => self -> m Double +getStartTime self + = liftIO + (realToFrac <$> + ({# call webkit_dom_text_track_cue_get_start_time #} + (toTextTrackCue self))) + +setEndTime :: + (MonadIO m, TextTrackCueClass self) => self -> Double -> m () +setEndTime self val + = liftIO + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_text_track_cue_set_end_time #} + (toTextTrackCue self) + (realToFrac val) + errorPtr_) + +getEndTime :: + (MonadIO m, TextTrackCueClass self) => self -> m Double +getEndTime self + = liftIO + (realToFrac <$> + ({# call webkit_dom_text_track_cue_get_end_time #} + (toTextTrackCue self))) + +setPauseOnExit :: + (MonadIO m, TextTrackCueClass self) => self -> Bool -> m () +setPauseOnExit self val + = liftIO + ({# call webkit_dom_text_track_cue_set_pause_on_exit #} + (toTextTrackCue self) + (fromBool val)) + +getPauseOnExit :: + (MonadIO m, TextTrackCueClass self) => self -> m Bool +getPauseOnExit self + = liftIO + (toBool <$> + ({# call webkit_dom_text_track_cue_get_pause_on_exit #} + (toTextTrackCue self))) + +enter :: (TextTrackCueClass self) => EventName self Event +enter = EventName "enter" + +exit :: (TextTrackCueClass self) => EventName self Event +exit = EventName "exit" +#endif diff --git a/Graphics/UI/Gtk/WebKit/DOM/TextTrackCueList.chs b/Graphics/UI/Gtk/WebKit/DOM/TextTrackCueList.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/TextTrackCueList.chs @@ -0,0 +1,58 @@ +module Graphics.UI.Gtk.WebKit.DOM.TextTrackCueList( +#if WEBKIT_CHECK_VERSION(2,2,2) +item, +getCueById, +getLength, +TextTrackCueList, +castToTextTrackCueList, +gTypeTextTrackCueList, +TextTrackCueListClass, +toTextTrackCueList, +#endif +) where +#if WEBKIT_CHECK_VERSION(2,2,2) +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures +import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + + +item :: + (MonadIO m, TextTrackCueListClass self) => + self -> Word -> m (Maybe TextTrackCue) +item self index + = liftIO + (maybeNull (makeNewGObject mkTextTrackCue) + ({# call webkit_dom_text_track_cue_list_item #} + (toTextTrackCueList self) + (fromIntegral index))) + +getCueById :: + (MonadIO m, TextTrackCueListClass self, GlibString string) => + self -> string -> m (Maybe TextTrackCue) +getCueById self id + = liftIO + (maybeNull (makeNewGObject mkTextTrackCue) + (withUTFString id $ + \ idPtr -> + {# call webkit_dom_text_track_cue_list_get_cue_by_id #} + (toTextTrackCueList self) + idPtr)) + +getLength :: + (MonadIO m, TextTrackCueListClass self) => self -> m Word +getLength self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_text_track_cue_list_get_length #} + (toTextTrackCueList self))) +#endif diff --git a/Graphics/UI/Gtk/WebKit/DOM/TextTrackList.chs b/Graphics/UI/Gtk/WebKit/DOM/TextTrackList.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/TextTrackList.chs @@ -0,0 +1,72 @@ +module Graphics.UI.Gtk.WebKit.DOM.TextTrackList( +#if WEBKIT_CHECK_VERSION(2,2,2) +item, +#if WEBKIT_CHECK_VERSION(2,4,0) +getTrackById, +#endif +getLength, +addTrack, +change, +removeTrack, +TextTrackList, +castToTextTrackList, +gTypeTextTrackList, +TextTrackListClass, +toTextTrackList, +#endif +) where +#if WEBKIT_CHECK_VERSION(2,2,2) +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures +import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + + +item :: + (MonadIO m, TextTrackListClass self) => + self -> Word -> m (Maybe TextTrack) +item self index + = liftIO + (maybeNull (makeNewGObject mkTextTrack) + ({# call webkit_dom_text_track_list_item #} (toTextTrackList self) + (fromIntegral index))) + +#if WEBKIT_CHECK_VERSION(2,4,0) +getTrackById :: + (MonadIO m, TextTrackListClass self, GlibString string) => + self -> string -> m (Maybe TextTrack) +getTrackById self id + = liftIO + (maybeNull (makeNewGObject mkTextTrack) + (withUTFString id $ + \ idPtr -> + {# call webkit_dom_text_track_list_get_track_by_id #} + (toTextTrackList self) + idPtr)) +#endif + +getLength :: (MonadIO m, TextTrackListClass self) => self -> m Word +getLength self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_text_track_list_get_length #} + (toTextTrackList self))) + +addTrack :: (TextTrackListClass self) => EventName self Event +addTrack = EventName "addtrack" + +change :: (TextTrackListClass self) => EventName self Event +change = EventName "change" + +removeTrack :: (TextTrackListClass self) => EventName self Event +removeTrack = EventName "removetrack" +#endif diff --git a/Graphics/UI/Gtk/WebKit/DOM/TimeRanges.chs b/Graphics/UI/Gtk/WebKit/DOM/TimeRanges.chs --- a/Graphics/UI/Gtk/WebKit/DOM/TimeRanges.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/TimeRanges.chs @@ -1,36 +1,52 @@ -module Graphics.UI.Gtk.WebKit.DOM.TimeRanges - (timeRangesStart, timeRangesEnd, timeRangesGetLength, - TimeRanges(..), TimeRangesClass(..), castToTimeRanges, - gTypeTimeRanges, toTimeRanges) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.TimeRanges( +start, +end, +getLength, +TimeRanges, +castToTimeRanges, +gTypeTimeRanges, +TimeRangesClass, +toTimeRanges, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -timeRangesStart :: - (TimeRangesClass self) => self -> Word -> IO Double -timeRangesStart self index - = realToFrac <$> - (propagateGError $ - \ errorPtr_ -> - {# call webkit_dom_time_ranges_start #} (toTimeRanges self) - (fromIntegral index) - errorPtr_) +start :: + (MonadIO m, TimeRangesClass self) => self -> Word -> m Double +start self index + = liftIO + (realToFrac <$> + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_time_ranges_start #} (toTimeRanges self) + (fromIntegral index) + errorPtr_)) -timeRangesEnd :: - (TimeRangesClass self) => self -> Word -> IO Double -timeRangesEnd self index - = realToFrac <$> - (propagateGError $ - \ errorPtr_ -> - {# call webkit_dom_time_ranges_end #} (toTimeRanges self) - (fromIntegral index) - errorPtr_) +end :: + (MonadIO m, TimeRangesClass self) => self -> Word -> m Double +end self index + = liftIO + (realToFrac <$> + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_time_ranges_end #} (toTimeRanges self) + (fromIntegral index) + errorPtr_)) -timeRangesGetLength :: (TimeRangesClass self) => self -> IO Word -timeRangesGetLength self - = fromIntegral <$> - ({# call webkit_dom_time_ranges_get_length #} (toTimeRanges self)) +getLength :: (MonadIO m, TimeRangesClass self) => self -> m Word +getLength self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_time_ranges_get_length #} (toTimeRanges self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/Touch.chs b/Graphics/UI/Gtk/WebKit/DOM/Touch.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/Touch.chs @@ -0,0 +1,112 @@ +module Graphics.UI.Gtk.WebKit.DOM.Touch( +#if WEBKIT_CHECK_VERSION(2,4,0) +getClientX, +getClientY, +getScreenX, +getScreenY, +getPageX, +getPageY, +getTarget, +getIdentifier, +getWebkitRadiusX, +getWebkitRadiusY, +getWebkitRotationAngle, +getWebkitForce, +Touch, +castToTouch, +gTypeTouch, +TouchClass, +toTouch, +#endif +) where +#if WEBKIT_CHECK_VERSION(2,4,0) +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures +import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + + +getClientX :: (MonadIO m, TouchClass self) => self -> m Int +getClientX self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_touch_get_client_x #} (toTouch self))) + +getClientY :: (MonadIO m, TouchClass self) => self -> m Int +getClientY self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_touch_get_client_y #} (toTouch self))) + +getScreenX :: (MonadIO m, TouchClass self) => self -> m Int +getScreenX self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_touch_get_screen_x #} (toTouch self))) + +getScreenY :: (MonadIO m, TouchClass self) => self -> m Int +getScreenY self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_touch_get_screen_y #} (toTouch self))) + +getPageX :: (MonadIO m, TouchClass self) => self -> m Int +getPageX self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_touch_get_page_x #} (toTouch self))) + +getPageY :: (MonadIO m, TouchClass self) => self -> m Int +getPageY self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_touch_get_page_y #} (toTouch self))) + +getTarget :: + (MonadIO m, TouchClass self) => self -> m (Maybe EventTarget) +getTarget self + = liftIO + (maybeNull (makeNewGObject mkEventTarget) + ({# call webkit_dom_touch_get_target #} (toTouch self))) + +getIdentifier :: (MonadIO m, TouchClass self) => self -> m Word +getIdentifier self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_touch_get_identifier #} (toTouch self))) + +getWebkitRadiusX :: (MonadIO m, TouchClass self) => self -> m Int +getWebkitRadiusX self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_touch_get_webkit_radius_x #} (toTouch self))) + +getWebkitRadiusY :: (MonadIO m, TouchClass self) => self -> m Int +getWebkitRadiusY self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_touch_get_webkit_radius_y #} (toTouch self))) + +getWebkitRotationAngle :: + (MonadIO m, TouchClass self) => self -> m Float +getWebkitRotationAngle self + = liftIO + (realToFrac <$> + ({# call webkit_dom_touch_get_webkit_rotation_angle #} + (toTouch self))) + +getWebkitForce :: (MonadIO m, TouchClass self) => self -> m Float +getWebkitForce self + = liftIO + (realToFrac <$> + ({# call webkit_dom_touch_get_webkit_force #} (toTouch self))) +#endif diff --git a/Graphics/UI/Gtk/WebKit/DOM/Traversal.chs b/Graphics/UI/Gtk/WebKit/DOM/Traversal.chs deleted file mode 100644 --- a/Graphics/UI/Gtk/WebKit/DOM/Traversal.chs +++ /dev/null @@ -1,8 +0,0 @@ -module Graphics.UI.Gtk.WebKit.DOM.Traversal - (NodeFilter, NodeFilterClass) where - -data NodeFilter = NodeFilter - -class NodeFilterClass a - -instance NodeFilterClass NodeFilter diff --git a/Graphics/UI/Gtk/WebKit/DOM/TreeWalker.chs b/Graphics/UI/Gtk/WebKit/DOM/TreeWalker.chs --- a/Graphics/UI/Gtk/WebKit/DOM/TreeWalker.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/TreeWalker.chs @@ -1,55 +1,77 @@ -module Graphics.UI.Gtk.WebKit.DOM.TreeWalker - (treeWalkerGetRoot, treeWalkerGetWhatToShow, treeWalkerGetFilter, - treeWalkerGetExpandEntityReferences, treeWalkerSetCurrentNode, - treeWalkerGetCurrentNode, TreeWalker(..), TreeWalkerClass(..), - castToTreeWalker, gTypeTreeWalker, toTreeWalker) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.TreeWalker( +getRoot, +getWhatToShow, +getFilter, +getExpandEntityReferences, +setCurrentNode, +getCurrentNode, +TreeWalker, +castToTreeWalker, +gTypeTreeWalker, +TreeWalkerClass, +toTreeWalker, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -treeWalkerGetRoot :: - (TreeWalkerClass self) => self -> IO (Maybe Node) -treeWalkerGetRoot self - = maybeNull (makeNewGObject mkNode) - ({# call webkit_dom_tree_walker_get_root #} (toTreeWalker self)) +getRoot :: + (MonadIO m, TreeWalkerClass self) => self -> m (Maybe Node) +getRoot self + = liftIO + (maybeNull (makeNewGObject mkNode) + ({# call webkit_dom_tree_walker_get_root #} (toTreeWalker self))) -treeWalkerGetWhatToShow :: - (TreeWalkerClass self) => self -> IO Word -treeWalkerGetWhatToShow self - = fromIntegral <$> - ({# call webkit_dom_tree_walker_get_what_to_show #} - (toTreeWalker self)) +getWhatToShow :: + (MonadIO m, TreeWalkerClass self) => self -> m Word +getWhatToShow self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_tree_walker_get_what_to_show #} + (toTreeWalker self))) -treeWalkerGetFilter :: - (TreeWalkerClass self) => self -> IO (Maybe NodeFilter) -treeWalkerGetFilter self - = maybeNull (makeNewGObject mkNodeFilter) - ({# call webkit_dom_tree_walker_get_filter #} (toTreeWalker self)) +getFilter :: + (MonadIO m, TreeWalkerClass self) => self -> m (Maybe NodeFilter) +getFilter self + = liftIO + (maybeNull (makeNewGObject mkNodeFilter) + ({# call webkit_dom_tree_walker_get_filter #} (toTreeWalker self))) -treeWalkerGetExpandEntityReferences :: - (TreeWalkerClass self) => self -> IO Bool -treeWalkerGetExpandEntityReferences self - = toBool <$> - ({# call webkit_dom_tree_walker_get_expand_entity_references #} - (toTreeWalker self)) +getExpandEntityReferences :: + (MonadIO m, TreeWalkerClass self) => self -> m Bool +getExpandEntityReferences self + = liftIO + (toBool <$> + ({# call webkit_dom_tree_walker_get_expand_entity_references #} + (toTreeWalker self))) -treeWalkerSetCurrentNode :: - (NodeClass val, TreeWalkerClass self) => self -> Maybe val -> IO () -treeWalkerSetCurrentNode self val - = propagateGError $ - \ errorPtr_ -> - {# call webkit_dom_tree_walker_set_current_node #} - (toTreeWalker self) - (maybe (Node nullForeignPtr) toNode val) - errorPtr_ +setCurrentNode :: + (MonadIO m, NodeClass val, TreeWalkerClass self) => + self -> Maybe val -> m () +setCurrentNode self val + = liftIO + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_tree_walker_set_current_node #} + (toTreeWalker self) + (maybe (Node nullForeignPtr) toNode val) + errorPtr_) -treeWalkerGetCurrentNode :: - (TreeWalkerClass self) => self -> IO (Maybe Node) -treeWalkerGetCurrentNode self - = maybeNull (makeNewGObject mkNode) - ({# call webkit_dom_tree_walker_get_current_node #} - (toTreeWalker self)) +getCurrentNode :: + (MonadIO m, TreeWalkerClass self) => self -> m (Maybe Node) +getCurrentNode self + = liftIO + (maybeNull (makeNewGObject mkNode) + ({# call webkit_dom_tree_walker_get_current_node #} + (toTreeWalker self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/UIEvent.chs b/Graphics/UI/Gtk/WebKit/DOM/UIEvent.chs --- a/Graphics/UI/Gtk/WebKit/DOM/UIEvent.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/UIEvent.chs @@ -1,71 +1,100 @@ -module Graphics.UI.Gtk.WebKit.DOM.UIEvent - (uiEventInitUIEvent, uiEventGetView, uiEventGetDetail, - uiEventGetKeyCode, uiEventGetCharCode, uiEventGetLayerX, - uiEventGetLayerY, uiEventGetPageX, uiEventGetPageY, - uiEventGetWhich, UIEvent, UIEventClass, castToUIEvent, - gTypeUIEvent, toUIEvent) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.UIEvent( +initUIEvent, +getView, +getDetail, +getKeyCode, +getCharCode, +getLayerX, +getLayerY, +getPageX, +getPageY, +getWhich, +UIEvent, +castToUIEvent, +gTypeUIEvent, +UIEventClass, +toUIEvent, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -uiEventInitUIEvent :: - (UIEventClass self, DOMWindowClass view) => - self -> String -> Bool -> Bool -> Maybe view -> Int -> IO () -uiEventInitUIEvent self type' canBubble cancelable view detail - = withUTFString type' $ - \ typePtr -> - {# call webkit_dom_ui_event_init_ui_event #} (toUIEvent self) - typePtr - (fromBool canBubble) - (fromBool cancelable) - (maybe (DOMWindow nullForeignPtr) toDOMWindow view) - (fromIntegral detail) +initUIEvent :: + (MonadIO m, UIEventClass self, WindowClass view, + GlibString string) => + self -> string -> Bool -> Bool -> Maybe view -> Int -> m () +initUIEvent self type' canBubble cancelable view detail + = liftIO + (withUTFString type' $ + \ typePtr -> + {# call webkit_dom_ui_event_init_ui_event #} (toUIEvent self) + typePtr + (fromBool canBubble) + (fromBool cancelable) + (maybe (Window nullForeignPtr) toWindow view) + (fromIntegral detail)) -uiEventGetView :: - (UIEventClass self) => self -> IO (Maybe DOMWindow) -uiEventGetView self - = maybeNull (makeNewGObject mkDOMWindow) - ({# call webkit_dom_ui_event_get_view #} (toUIEvent self)) +getView :: + (MonadIO m, UIEventClass self) => self -> m (Maybe Window) +getView self + = liftIO + (maybeNull (makeNewGObject mkWindow) + ({# call webkit_dom_ui_event_get_view #} (toUIEvent self))) -uiEventGetDetail :: (UIEventClass self) => self -> IO Int -uiEventGetDetail self - = fromIntegral <$> - ({# call webkit_dom_ui_event_get_detail #} (toUIEvent self)) +getDetail :: (MonadIO m, UIEventClass self) => self -> m Int +getDetail self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_ui_event_get_detail #} (toUIEvent self))) -uiEventGetKeyCode :: (UIEventClass self) => self -> IO Int -uiEventGetKeyCode self - = fromIntegral <$> - ({# call webkit_dom_ui_event_get_key_code #} (toUIEvent self)) +getKeyCode :: (MonadIO m, UIEventClass self) => self -> m Int +getKeyCode self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_ui_event_get_key_code #} (toUIEvent self))) -uiEventGetCharCode :: (UIEventClass self) => self -> IO Int -uiEventGetCharCode self - = fromIntegral <$> - ({# call webkit_dom_ui_event_get_char_code #} (toUIEvent self)) +getCharCode :: (MonadIO m, UIEventClass self) => self -> m Int +getCharCode self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_ui_event_get_char_code #} (toUIEvent self))) -uiEventGetLayerX :: (UIEventClass self) => self -> IO Int -uiEventGetLayerX self - = fromIntegral <$> - ({# call webkit_dom_ui_event_get_layer_x #} (toUIEvent self)) +getLayerX :: (MonadIO m, UIEventClass self) => self -> m Int +getLayerX self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_ui_event_get_layer_x #} (toUIEvent self))) -uiEventGetLayerY :: (UIEventClass self) => self -> IO Int -uiEventGetLayerY self - = fromIntegral <$> - ({# call webkit_dom_ui_event_get_layer_y #} (toUIEvent self)) +getLayerY :: (MonadIO m, UIEventClass self) => self -> m Int +getLayerY self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_ui_event_get_layer_y #} (toUIEvent self))) -uiEventGetPageX :: (UIEventClass self) => self -> IO Int -uiEventGetPageX self - = fromIntegral <$> - ({# call webkit_dom_ui_event_get_page_x #} (toUIEvent self)) +getPageX :: (MonadIO m, UIEventClass self) => self -> m Int +getPageX self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_ui_event_get_page_x #} (toUIEvent self))) -uiEventGetPageY :: (UIEventClass self) => self -> IO Int -uiEventGetPageY self - = fromIntegral <$> - ({# call webkit_dom_ui_event_get_page_y #} (toUIEvent self)) +getPageY :: (MonadIO m, UIEventClass self) => self -> m Int +getPageY self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_ui_event_get_page_y #} (toUIEvent self))) -uiEventGetWhich :: (UIEventClass self) => self -> IO Int -uiEventGetWhich self - = fromIntegral <$> - ({# call webkit_dom_ui_event_get_which #} (toUIEvent self)) +getWhich :: (MonadIO m, UIEventClass self) => self -> m Int +getWhich self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_ui_event_get_which #} (toUIEvent self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/ValidityState.chs b/Graphics/UI/Gtk/WebKit/DOM/ValidityState.chs --- a/Graphics/UI/Gtk/WebKit/DOM/ValidityState.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/ValidityState.chs @@ -1,90 +1,114 @@ -module Graphics.UI.Gtk.WebKit.DOM.ValidityState - (validityStateGetValueMissing, validityStateGetTypeMismatch, - validityStateGetPatternMismatch, validityStateGetTooLong, - validityStateGetRangeUnderflow, validityStateGetRangeOverflow, - validityStateGetStepMismatch, +module Graphics.UI.Gtk.WebKit.DOM.ValidityState( +getValueMissing, +getTypeMismatch, +getPatternMismatch, +getTooLong, +getRangeUnderflow, +getRangeOverflow, +getStepMismatch, #if WEBKIT_CHECK_VERSION(2,2,2) - validityStateGetBadInput, +getBadInput, #endif - validityStateGetCustomError, validityStateGetValid, ValidityState, - ValidityStateClass, castToValidityState, gTypeValidityState, - toValidityState) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +getCustomError, +getValid, +ValidityState, +castToValidityState, +gTypeValidityState, +ValidityStateClass, +toValidityState, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM - -validityStateGetValueMissing :: - (ValidityStateClass self) => self -> IO Bool -validityStateGetValueMissing self - = toBool <$> - ({# call webkit_dom_validity_state_get_value_missing #} - (toValidityState self)) +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -validityStateGetTypeMismatch :: - (ValidityStateClass self) => self -> IO Bool -validityStateGetTypeMismatch self - = toBool <$> - ({# call webkit_dom_validity_state_get_type_mismatch #} - (toValidityState self)) +getValueMissing :: + (MonadIO m, ValidityStateClass self) => self -> m Bool +getValueMissing self + = liftIO + (toBool <$> + ({# call webkit_dom_validity_state_get_value_missing #} + (toValidityState self))) -validityStateGetPatternMismatch :: - (ValidityStateClass self) => self -> IO Bool -validityStateGetPatternMismatch self - = toBool <$> - ({# call webkit_dom_validity_state_get_pattern_mismatch #} - (toValidityState self)) +getTypeMismatch :: + (MonadIO m, ValidityStateClass self) => self -> m Bool +getTypeMismatch self + = liftIO + (toBool <$> + ({# call webkit_dom_validity_state_get_type_mismatch #} + (toValidityState self))) -validityStateGetTooLong :: - (ValidityStateClass self) => self -> IO Bool -validityStateGetTooLong self - = toBool <$> - ({# call webkit_dom_validity_state_get_too_long #} - (toValidityState self)) +getPatternMismatch :: + (MonadIO m, ValidityStateClass self) => self -> m Bool +getPatternMismatch self + = liftIO + (toBool <$> + ({# call webkit_dom_validity_state_get_pattern_mismatch #} + (toValidityState self))) -validityStateGetRangeUnderflow :: - (ValidityStateClass self) => self -> IO Bool -validityStateGetRangeUnderflow self - = toBool <$> - ({# call webkit_dom_validity_state_get_range_underflow #} - (toValidityState self)) +getTooLong :: + (MonadIO m, ValidityStateClass self) => self -> m Bool +getTooLong self + = liftIO + (toBool <$> + ({# call webkit_dom_validity_state_get_too_long #} + (toValidityState self))) -validityStateGetRangeOverflow :: - (ValidityStateClass self) => self -> IO Bool -validityStateGetRangeOverflow self - = toBool <$> - ({# call webkit_dom_validity_state_get_range_overflow #} - (toValidityState self)) +getRangeUnderflow :: + (MonadIO m, ValidityStateClass self) => self -> m Bool +getRangeUnderflow self + = liftIO + (toBool <$> + ({# call webkit_dom_validity_state_get_range_underflow #} + (toValidityState self))) -validityStateGetStepMismatch :: - (ValidityStateClass self) => self -> IO Bool -validityStateGetStepMismatch self - = toBool <$> - ({# call webkit_dom_validity_state_get_step_mismatch #} - (toValidityState self)) +getRangeOverflow :: + (MonadIO m, ValidityStateClass self) => self -> m Bool +getRangeOverflow self + = liftIO + (toBool <$> + ({# call webkit_dom_validity_state_get_range_overflow #} + (toValidityState self))) -#if WEBKIT_CHECK_VERSION(2,2,2) -validityStateGetBadInput :: - (ValidityStateClass self) => self -> IO Bool -validityStateGetBadInput self - = toBool <$> - ({# call webkit_dom_validity_state_get_bad_input #} - (toValidityState self)) +getStepMismatch :: + (MonadIO m, ValidityStateClass self) => self -> m Bool +getStepMismatch self + = liftIO + (toBool <$> + ({# call webkit_dom_validity_state_get_step_mismatch #} + (toValidityState self))) + +#if WEBKIT_CHECK_VERSION(2,2,2) +getBadInput :: + (MonadIO m, ValidityStateClass self) => self -> m Bool +getBadInput self + = liftIO + (toBool <$> + ({# call webkit_dom_validity_state_get_bad_input #} + (toValidityState self))) #endif -validityStateGetCustomError :: - (ValidityStateClass self) => self -> IO Bool -validityStateGetCustomError self - = toBool <$> - ({# call webkit_dom_validity_state_get_custom_error #} - (toValidityState self)) +getCustomError :: + (MonadIO m, ValidityStateClass self) => self -> m Bool +getCustomError self + = liftIO + (toBool <$> + ({# call webkit_dom_validity_state_get_custom_error #} + (toValidityState self))) -validityStateGetValid :: - (ValidityStateClass self) => self -> IO Bool -validityStateGetValid self - = toBool <$> - ({# call webkit_dom_validity_state_get_valid #} - (toValidityState self)) +getValid :: (MonadIO m, ValidityStateClass self) => self -> m Bool +getValid self + = liftIO + (toBool <$> + ({# call webkit_dom_validity_state_get_valid #} + (toValidityState self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/VideoTrack.chs b/Graphics/UI/Gtk/WebKit/DOM/VideoTrack.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/VideoTrack.chs @@ -0,0 +1,60 @@ +module Graphics.UI.Gtk.WebKit.DOM.VideoTrack( +#if WEBKIT_CHECK_VERSION(2,2,2) +getId, +getLabel, +setSelected, +getSelected, +VideoTrack, +castToVideoTrack, +gTypeVideoTrack, +VideoTrackClass, +toVideoTrack, +#endif +) where +#if WEBKIT_CHECK_VERSION(2,2,2) +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures +import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + + +getId :: + (MonadIO m, VideoTrackClass self, GlibString string) => + self -> m string +getId self + = liftIO + (({# call webkit_dom_video_track_get_id #} (toVideoTrack self)) >>= + readUTFString) + +getLabel :: + (MonadIO m, VideoTrackClass self, GlibString string) => + self -> m string +getLabel self + = liftIO + (({# call webkit_dom_video_track_get_label #} (toVideoTrack self)) + >>= + readUTFString) + +setSelected :: + (MonadIO m, VideoTrackClass self) => self -> Bool -> m () +setSelected self val + = liftIO + ({# call webkit_dom_video_track_set_selected #} (toVideoTrack self) + (fromBool val)) + +getSelected :: (MonadIO m, VideoTrackClass self) => self -> m Bool +getSelected self + = liftIO + (toBool <$> + ({# call webkit_dom_video_track_get_selected #} + (toVideoTrack self))) +#endif diff --git a/Graphics/UI/Gtk/WebKit/DOM/VideoTrackList.chs b/Graphics/UI/Gtk/WebKit/DOM/VideoTrackList.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/VideoTrackList.chs @@ -0,0 +1,83 @@ +module Graphics.UI.Gtk.WebKit.DOM.VideoTrackList( +#if WEBKIT_CHECK_VERSION(2,2,2) +item, +getTrackById, +getLength, +#if WEBKIT_CHECK_VERSION(99,0,0) +getSelectedIndex, +#endif +change, +addTrack, +removeTrack, +VideoTrackList, +castToVideoTrackList, +gTypeVideoTrackList, +VideoTrackListClass, +toVideoTrackList, +#endif +) where +#if WEBKIT_CHECK_VERSION(2,2,2) +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures +import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + + +item :: + (MonadIO m, VideoTrackListClass self) => + self -> Word -> m (Maybe VideoTrack) +item self index + = liftIO + (maybeNull (makeNewGObject mkVideoTrack) + ({# call webkit_dom_video_track_list_item #} + (toVideoTrackList self) + (fromIntegral index))) + +getTrackById :: + (MonadIO m, VideoTrackListClass self, GlibString string) => + self -> string -> m (Maybe VideoTrack) +getTrackById self id + = liftIO + (maybeNull (makeNewGObject mkVideoTrack) + (withUTFString id $ + \ idPtr -> + {# call webkit_dom_video_track_list_get_track_by_id #} + (toVideoTrackList self) + idPtr)) + +getLength :: + (MonadIO m, VideoTrackListClass self) => self -> m Word +getLength self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_video_track_list_get_length #} + (toVideoTrackList self))) + +#if WEBKIT_CHECK_VERSION(99,0,0) +getSelectedIndex :: + (MonadIO m, VideoTrackListClass self) => self -> m Int +getSelectedIndex self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_video_track_list_get_selected_index #} + (toVideoTrackList self))) +#endif + +change :: (VideoTrackListClass self) => EventName self Event +change = EventName "change" + +addTrack :: (VideoTrackListClass self) => EventName self Event +addTrack = EventName "addtrack" + +removeTrack :: (VideoTrackListClass self) => EventName self Event +removeTrack = EventName "removetrack" +#endif diff --git a/Graphics/UI/Gtk/WebKit/DOM/WebKitNamedFlow.chs b/Graphics/UI/Gtk/WebKit/DOM/WebKitNamedFlow.chs --- a/Graphics/UI/Gtk/WebKit/DOM/WebKitNamedFlow.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/WebKitNamedFlow.chs @@ -1,78 +1,86 @@ -module Graphics.UI.Gtk.WebKit.DOM.WebKitNamedFlow - ( -#if WEBKIT_CHECK_VERSION(1,10,0) - webKitNamedFlowGetRegionsByContent, webKitNamedFlowGetRegions, - webKitNamedFlowGetContent, webKitNamedFlowDispatchEvent, - webKitNamedFlowGetName, webKitNamedFlowGetOverset, - webKitNamedFlowGetFirstEmptyRegionIndex, WebKitNamedFlow, - WebKitNamedFlowClass, castToWebKitNamedFlow, gTypeWebKitNamedFlow, - toWebKitNamedFlow +module Graphics.UI.Gtk.WebKit.DOM.WebKitNamedFlow( +#if WEBKIT_CHECK_VERSION(2,2,2) +getRegionsByContent, +getRegions, +getContent, +getName, +getOverset, +getFirstEmptyRegionIndex, #endif - ) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +WebKitNamedFlow, +castToWebKitNamedFlow, +gTypeWebKitNamedFlow, +WebKitNamedFlowClass, +toWebKitNamedFlow, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM - -#if WEBKIT_CHECK_VERSION(1,10,0) -webKitNamedFlowGetRegionsByContent :: - (WebKitNamedFlowClass self, NodeClass contentNode) => - self -> Maybe contentNode -> IO (Maybe NodeList) -webKitNamedFlowGetRegionsByContent self contentNode - = maybeNull (makeNewGObject mkNodeList) - ({# call webkit_dom_webkit_named_flow_get_regions_by_content #} - (toWebKitNamedFlow self) - (maybe (Node nullForeignPtr) toNode contentNode)) - -webKitNamedFlowGetRegions :: - (WebKitNamedFlowClass self) => self -> IO (Maybe NodeList) -webKitNamedFlowGetRegions self - = maybeNull (makeNewGObject mkNodeList) - ({# call webkit_dom_webkit_named_flow_get_regions #} - (toWebKitNamedFlow self)) +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + + +#if WEBKIT_CHECK_VERSION(2,2,2) +getRegionsByContent :: + (MonadIO m, WebKitNamedFlowClass self, NodeClass contentNode) => + self -> Maybe contentNode -> m (Maybe NodeList) +getRegionsByContent self contentNode + = liftIO + (maybeNull (makeNewGObject mkNodeList) + ({# call webkit_dom_webkit_named_flow_get_regions_by_content #} + (toWebKitNamedFlow self) + (maybe (Node nullForeignPtr) toNode contentNode))) -webKitNamedFlowGetContent :: - (WebKitNamedFlowClass self) => self -> IO (Maybe NodeList) -webKitNamedFlowGetContent self - = maybeNull (makeNewGObject mkNodeList) - ({# call webkit_dom_webkit_named_flow_get_content #} - (toWebKitNamedFlow self)) +getRegions :: + (MonadIO m, WebKitNamedFlowClass self) => + self -> m (Maybe NodeList) +getRegions self + = liftIO + (maybeNull (makeNewGObject mkNodeList) + ({# call webkit_dom_webkit_named_flow_get_regions #} + (toWebKitNamedFlow self))) -webKitNamedFlowDispatchEvent :: - (WebKitNamedFlowClass self, EventClass event) => - self -> Maybe event -> IO Bool -webKitNamedFlowDispatchEvent self event - = toBool <$> - (propagateGError $ - \ errorPtr_ -> - {# call webkit_dom_webkit_named_flow_dispatch_event #} - (toWebKitNamedFlow self) - (maybe (Event nullForeignPtr) toEvent event) - errorPtr_) +getContent :: + (MonadIO m, WebKitNamedFlowClass self) => + self -> m (Maybe NodeList) +getContent self + = liftIO + (maybeNull (makeNewGObject mkNodeList) + ({# call webkit_dom_webkit_named_flow_get_content #} + (toWebKitNamedFlow self))) -webKitNamedFlowGetName :: - (WebKitNamedFlowClass self) => self -> IO String -webKitNamedFlowGetName self - = ({# call webkit_dom_webkit_named_flow_get_name #} - (toWebKitNamedFlow self)) - >>= - readUTFString +getName :: + (MonadIO m, WebKitNamedFlowClass self, GlibString string) => + self -> m string +getName self + = liftIO + (({# call webkit_dom_webkit_named_flow_get_name #} + (toWebKitNamedFlow self)) + >>= + readUTFString) -webKitNamedFlowGetOverset :: - (WebKitNamedFlowClass self) => self -> IO Bool -webKitNamedFlowGetOverset self - = toBool <$> - ({# call webkit_dom_webkit_named_flow_get_overset #} - (toWebKitNamedFlow self)) +getOverset :: + (MonadIO m, WebKitNamedFlowClass self) => self -> m Bool +getOverset self + = liftIO + (toBool <$> + ({# call webkit_dom_webkit_named_flow_get_overset #} + (toWebKitNamedFlow self))) -webKitNamedFlowGetFirstEmptyRegionIndex :: - (WebKitNamedFlowClass self) => self -> IO Int -webKitNamedFlowGetFirstEmptyRegionIndex self - = fromIntegral <$> - ({# call webkit_dom_webkit_named_flow_get_first_empty_region_index - #} - (toWebKitNamedFlow self)) +getFirstEmptyRegionIndex :: + (MonadIO m, WebKitNamedFlowClass self) => self -> m Int +getFirstEmptyRegionIndex self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_webkit_named_flow_get_first_empty_region_index + #} + (toWebKitNamedFlow self))) #endif diff --git a/Graphics/UI/Gtk/WebKit/DOM/WebKitPoint.chs b/Graphics/UI/Gtk/WebKit/DOM/WebKitPoint.chs --- a/Graphics/UI/Gtk/WebKit/DOM/WebKitPoint.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/WebKitPoint.chs @@ -1,33 +1,49 @@ -module Graphics.UI.Gtk.WebKit.DOM.WebKitPoint - (webKitPointSetX, webKitPointGetX, webKitPointSetY, - webKitPointGetY, WebKitPoint, WebKitPointClass, castToWebKitPoint, - gTypeWebKitPoint, toWebKitPoint) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.WebKitPoint( +setX, +getX, +setY, +getY, +WebKitPoint, +castToWebKitPoint, +gTypeWebKitPoint, +WebKitPointClass, +toWebKitPoint, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -webKitPointSetX :: - (WebKitPointClass self) => self -> Float -> IO () -webKitPointSetX self val - = {# call webkit_dom_webkit_point_set_x #} (toWebKitPoint self) - (realToFrac val) +setX :: (MonadIO m, WebKitPointClass self) => self -> Float -> m () +setX self val + = liftIO + ({# call webkit_dom_webkit_point_set_x #} (toWebKitPoint self) + (realToFrac val)) -webKitPointGetX :: (WebKitPointClass self) => self -> IO Float -webKitPointGetX self - = realToFrac <$> - ({# call webkit_dom_webkit_point_get_x #} (toWebKitPoint self)) +getX :: (MonadIO m, WebKitPointClass self) => self -> m Float +getX self + = liftIO + (realToFrac <$> + ({# call webkit_dom_webkit_point_get_x #} (toWebKitPoint self))) -webKitPointSetY :: - (WebKitPointClass self) => self -> Float -> IO () -webKitPointSetY self val - = {# call webkit_dom_webkit_point_set_y #} (toWebKitPoint self) - (realToFrac val) +setY :: (MonadIO m, WebKitPointClass self) => self -> Float -> m () +setY self val + = liftIO + ({# call webkit_dom_webkit_point_set_y #} (toWebKitPoint self) + (realToFrac val)) -webKitPointGetY :: (WebKitPointClass self) => self -> IO Float -webKitPointGetY self - = realToFrac <$> - ({# call webkit_dom_webkit_point_get_y #} (toWebKitPoint self)) +getY :: (MonadIO m, WebKitPointClass self) => self -> m Float +getY self + = liftIO + (realToFrac <$> + ({# call webkit_dom_webkit_point_get_y #} (toWebKitPoint self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/WheelEvent.chs b/Graphics/UI/Gtk/WebKit/DOM/WheelEvent.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/WheelEvent.chs @@ -0,0 +1,125 @@ +module Graphics.UI.Gtk.WebKit.DOM.WheelEvent( +#if WEBKIT_CHECK_VERSION(2,4,0) +initWheelEvent, +pattern DOM_DELTA_PIXEL, +pattern DOM_DELTA_LINE, +pattern DOM_DELTA_PAGE, +getDeltaX, +getDeltaY, +getDeltaZ, +getDeltaMode, +getWheelDeltaX, +getWheelDeltaY, +getWheelDelta, +getWebkitDirectionInvertedFromDevice, +WheelEvent, +castToWheelEvent, +gTypeWheelEvent, +WheelEventClass, +toWheelEvent, +#endif +) where +#if WEBKIT_CHECK_VERSION(2,4,0) +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures +import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + + +initWheelEvent :: + (MonadIO m, WheelEventClass self, WindowClass view) => + self -> + Int -> + Int -> + Maybe view -> + Int -> Int -> Int -> Int -> Bool -> Bool -> Bool -> Bool -> m () +initWheelEvent self wheelDeltaX wheelDeltaY view screenX screenY + clientX clientY ctrlKey altKey shiftKey metaKey + = liftIO + ({# call webkit_dom_wheel_event_init_wheel_event #} + (toWheelEvent self) + (fromIntegral wheelDeltaX) + (fromIntegral wheelDeltaY) + (maybe (Window nullForeignPtr) toWindow view) + (fromIntegral screenX) + (fromIntegral screenY) + (fromIntegral clientX) + (fromIntegral clientY) + (fromBool ctrlKey) + (fromBool altKey) + (fromBool shiftKey) + (fromBool metaKey)) +pattern DOM_DELTA_PIXEL = 0 +pattern DOM_DELTA_LINE = 1 +pattern DOM_DELTA_PAGE = 2 + +getDeltaX :: (MonadIO m, WheelEventClass self) => self -> m Double +getDeltaX self + = liftIO + (realToFrac <$> + ({# call webkit_dom_wheel_event_get_delta_x #} + (toWheelEvent self))) + +getDeltaY :: (MonadIO m, WheelEventClass self) => self -> m Double +getDeltaY self + = liftIO + (realToFrac <$> + ({# call webkit_dom_wheel_event_get_delta_y #} + (toWheelEvent self))) + +getDeltaZ :: (MonadIO m, WheelEventClass self) => self -> m Double +getDeltaZ self + = liftIO + (realToFrac <$> + ({# call webkit_dom_wheel_event_get_delta_z #} + (toWheelEvent self))) + +getDeltaMode :: (MonadIO m, WheelEventClass self) => self -> m Word +getDeltaMode self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_wheel_event_get_delta_mode #} + (toWheelEvent self))) + +getWheelDeltaX :: + (MonadIO m, WheelEventClass self) => self -> m Int +getWheelDeltaX self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_wheel_event_get_wheel_delta_x #} + (toWheelEvent self))) + +getWheelDeltaY :: + (MonadIO m, WheelEventClass self) => self -> m Int +getWheelDeltaY self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_wheel_event_get_wheel_delta_y #} + (toWheelEvent self))) + +getWheelDelta :: (MonadIO m, WheelEventClass self) => self -> m Int +getWheelDelta self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_wheel_event_get_wheel_delta #} + (toWheelEvent self))) + +getWebkitDirectionInvertedFromDevice :: + (MonadIO m, WheelEventClass self) => self -> m Bool +getWebkitDirectionInvertedFromDevice self + = liftIO + (toBool <$> + ({# call + webkit_dom_wheel_event_get_webkit_direction_inverted_from_device + #} + (toWheelEvent self))) +#endif diff --git a/Graphics/UI/Gtk/WebKit/DOM/Window.chs b/Graphics/UI/Gtk/WebKit/DOM/Window.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/Window.chs @@ -0,0 +1,995 @@ +module Graphics.UI.Gtk.WebKit.DOM.Window( +getSelection, +blur, +print, +stop, +alert, +confirm, +prompt, +find, +scrollBy, +scrollTo, +scroll, +moveBy, +moveTo, +resizeBy, +resizeTo, +matchMedia, +getComputedStyle, +webkitConvertPointFromPageToNode, +webkitConvertPointFromNodeToPage, +captureEvents, +releaseEvents, +#if WEBKIT_CHECK_VERSION(2,2,2) +getWebkitStorageInfo, +#endif +getScreen, +getHistory, +#if WEBKIT_CHECK_VERSION(2,2,2) +getLocationbar, +getMenubar, +getPersonalbar, +getScrollbars, +getStatusbar, +getToolbar, +#endif +getNavigator, +getClientInformation, +getFrameElement, +getOffscreenBuffering, +getOuterHeight, +getOuterWidth, +getInnerHeight, +getInnerWidth, +getScreenX, +getScreenY, +getScreenLeft, +getScreenTop, +getScrollX, +getScrollY, +getPageXOffset, +getPageYOffset, +getClosed, +getLength, +setName, +getName, +setStatus, +getStatus, +setDefaultStatus, +getDefaultStatus, +getSelf, +getWindow, +getFrames, +getOpener, +getParent, +getTop, +getDocument, +getStyleMedia, +getDevicePixelRatio, +getApplicationCache, +getSessionStorage, +getLocalStorage, +#if WEBKIT_CHECK_VERSION(2,2,2) +getPerformance, +getCSS, +#endif +abort, +beforeUnload, +blurEvent, +canPlay, +canPlayThrough, +change, +click, +contextMenu, +dblClick, +drag, +dragEnd, +dragEnter, +dragLeave, +dragOver, +dragStart, +drop, +durationChange, +emptied, +ended, +error, +focusEvent, +hashChange, +input, +invalid, +#if WEBKIT_CHECK_VERSION(2,2,2) +keyDown, +keyPress, +keyUp, +#endif +load, +loadedData, +loadedMetadata, +loadStart, +message, +mouseDown, +mouseEnter, +mouseLeave, +mouseMove, +mouseOut, +mouseOver, +mouseUp, +mouseWheel, +offline, +online, +pageHide, +pageShow, +pause, +play, +playing, +popState, +progress, +rateChange, +resize, +scrollEvent, +seeked, +seeking, +select, +stalled, +storage, +submit, +suspend, +timeUpdate, +unload, +volumeChange, +waiting, +#if WEBKIT_CHECK_VERSION(2,4,0) +wheel, +#endif +reset, +search, +webKitAnimationEnd, +webKitAnimationIteration, +webKitAnimationStart, +animationEnd, +animationIteration, +animationStart, +webKitTransitionEnd, +transitionEnd, +touchStart, +touchMove, +touchEnd, +touchCancel, +gestureStart, +gestureChange, +gestureEnd, +deviceMotion, +deviceOrientation, +webKitDeviceProximity, +webKitWillRevealBottom, +webKitWillRevealLeft, +webKitWillRevealRight, +webKitWillRevealTop, +Window, +castToWindow, +gTypeWindow, +WindowClass, +toWindow, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures +import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + + +getSelection :: + (MonadIO m, WindowClass self) => self -> m (Maybe Selection) +getSelection self + = liftIO + (maybeNull (makeNewGObject mkSelection) + ({# call webkit_dom_dom_window_get_selection #} (toWindow self))) + +blur :: (MonadIO m, WindowClass self) => self -> m () +blur self + = liftIO ({# call webkit_dom_dom_window_blur #} (toWindow self)) + +print :: (MonadIO m, WindowClass self) => self -> m () +print self + = liftIO ({# call webkit_dom_dom_window_print #} (toWindow self)) + +stop :: (MonadIO m, WindowClass self) => self -> m () +stop self + = liftIO ({# call webkit_dom_dom_window_stop #} (toWindow self)) + +alert :: + (MonadIO m, WindowClass self, GlibString string) => + self -> string -> m () +alert self message + = liftIO + (withUTFString message $ + \ messagePtr -> + {# call webkit_dom_dom_window_alert #} (toWindow self) messagePtr) + +confirm :: + (MonadIO m, WindowClass self, GlibString string) => + self -> string -> m Bool +confirm self message + = liftIO + (toBool <$> + (withUTFString message $ + \ messagePtr -> + {# call webkit_dom_dom_window_confirm #} (toWindow self) + messagePtr)) + +prompt :: + (MonadIO m, WindowClass self, GlibString string) => + self -> string -> (Maybe string) -> m (Maybe string) +prompt self message defaultValue + = liftIO + ((maybeWith withUTFString defaultValue $ + \ defaultValuePtr -> + withUTFString message $ + \ messagePtr -> + {# call webkit_dom_dom_window_prompt #} (toWindow self) messagePtr + defaultValuePtr) + >>= + maybePeek readUTFString) + +find :: + (MonadIO m, WindowClass self, GlibString string) => + self -> + string -> Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> m Bool +find self string caseSensitive backwards wrap wholeWord + searchInFrames showDialog + = liftIO + (toBool <$> + (withUTFString string $ + \ stringPtr -> + {# call webkit_dom_dom_window_find #} (toWindow self) stringPtr + (fromBool caseSensitive) + (fromBool backwards) + (fromBool wrap) + (fromBool wholeWord) + (fromBool searchInFrames) + (fromBool showDialog))) + +scrollBy :: + (MonadIO m, WindowClass self) => self -> Int -> Int -> m () +scrollBy self x y + = liftIO + ({# call webkit_dom_dom_window_scroll_by #} (toWindow self) + (fromIntegral x) + (fromIntegral y)) + +scrollTo :: + (MonadIO m, WindowClass self) => self -> Int -> Int -> m () +scrollTo self x y + = liftIO + ({# call webkit_dom_dom_window_scroll_to #} (toWindow self) + (fromIntegral x) + (fromIntegral y)) + +scroll :: + (MonadIO m, WindowClass self) => self -> Int -> Int -> m () +scroll self x y + = liftIO + ({# call webkit_dom_dom_window_scroll #} (toWindow self) + (fromIntegral x) + (fromIntegral y)) + +moveBy :: + (MonadIO m, WindowClass self) => self -> Float -> Float -> m () +moveBy self x y + = liftIO + ({# call webkit_dom_dom_window_move_by #} (toWindow self) + (realToFrac x) + (realToFrac y)) + +moveTo :: + (MonadIO m, WindowClass self) => self -> Float -> Float -> m () +moveTo self x y + = liftIO + ({# call webkit_dom_dom_window_move_to #} (toWindow self) + (realToFrac x) + (realToFrac y)) + +resizeBy :: + (MonadIO m, WindowClass self) => self -> Float -> Float -> m () +resizeBy self x y + = liftIO + ({# call webkit_dom_dom_window_resize_by #} (toWindow self) + (realToFrac x) + (realToFrac y)) + +resizeTo :: + (MonadIO m, WindowClass self) => self -> Float -> Float -> m () +resizeTo self width height + = liftIO + ({# call webkit_dom_dom_window_resize_to #} (toWindow self) + (realToFrac width) + (realToFrac height)) + +matchMedia :: + (MonadIO m, WindowClass self, GlibString string) => + self -> string -> m (Maybe MediaQueryList) +matchMedia self query + = liftIO + (maybeNull (makeNewGObject mkMediaQueryList) + (withUTFString query $ + \ queryPtr -> + {# call webkit_dom_dom_window_match_media #} (toWindow self) + queryPtr)) + +getComputedStyle :: + (MonadIO m, WindowClass self, ElementClass element, + GlibString string) => + self -> + Maybe element -> (Maybe string) -> m (Maybe CSSStyleDeclaration) +getComputedStyle self element pseudoElement + = liftIO + (maybeNull (makeNewGObject mkCSSStyleDeclaration) + (maybeWith withUTFString pseudoElement $ + \ pseudoElementPtr -> + {# call webkit_dom_dom_window_get_computed_style #} (toWindow self) + (maybe (Element nullForeignPtr) toElement element) + pseudoElementPtr)) + +webkitConvertPointFromPageToNode :: + (MonadIO m, WindowClass self, NodeClass node, + WebKitPointClass p) => + self -> Maybe node -> Maybe p -> m (Maybe WebKitPoint) +webkitConvertPointFromPageToNode self node p + = liftIO + (maybeNull (makeNewGObject mkWebKitPoint) + ({# call + webkit_dom_dom_window_webkit_convert_point_from_page_to_node + #} + (toWindow self) + (maybe (Node nullForeignPtr) toNode node) + (maybe (WebKitPoint nullForeignPtr) toWebKitPoint p))) + +webkitConvertPointFromNodeToPage :: + (MonadIO m, WindowClass self, NodeClass node, + WebKitPointClass p) => + self -> Maybe node -> Maybe p -> m (Maybe WebKitPoint) +webkitConvertPointFromNodeToPage self node p + = liftIO + (maybeNull (makeNewGObject mkWebKitPoint) + ({# call + webkit_dom_dom_window_webkit_convert_point_from_node_to_page + #} + (toWindow self) + (maybe (Node nullForeignPtr) toNode node) + (maybe (WebKitPoint nullForeignPtr) toWebKitPoint p))) + +captureEvents :: (MonadIO m, WindowClass self) => self -> m () +captureEvents self + = liftIO + ({# call webkit_dom_dom_window_capture_events #} (toWindow self)) + +releaseEvents :: (MonadIO m, WindowClass self) => self -> m () +releaseEvents self + = liftIO + ({# call webkit_dom_dom_window_release_events #} (toWindow self)) + +#if WEBKIT_CHECK_VERSION(2,2,2) +getWebkitStorageInfo :: + (MonadIO m, WindowClass self) => self -> m (Maybe StorageInfo) +getWebkitStorageInfo self + = liftIO + (maybeNull (makeNewGObject mkStorageInfo) + ({# call webkit_dom_dom_window_get_webkit_storage_info #} + (toWindow self))) +#endif + +getScreen :: + (MonadIO m, WindowClass self) => self -> m (Maybe Screen) +getScreen self + = liftIO + (maybeNull (makeNewGObject mkScreen) + ({# call webkit_dom_dom_window_get_screen #} (toWindow self))) + +getHistory :: + (MonadIO m, WindowClass self) => self -> m (Maybe History) +getHistory self + = liftIO + (maybeNull (makeNewGObject mkHistory) + ({# call webkit_dom_dom_window_get_history #} (toWindow self))) + +#if WEBKIT_CHECK_VERSION(2,2,2) +getLocationbar :: + (MonadIO m, WindowClass self) => self -> m (Maybe BarProp) +getLocationbar self + = liftIO + (maybeNull (makeNewGObject mkBarProp) + ({# call webkit_dom_dom_window_get_locationbar #} (toWindow self))) + +getMenubar :: + (MonadIO m, WindowClass self) => self -> m (Maybe BarProp) +getMenubar self + = liftIO + (maybeNull (makeNewGObject mkBarProp) + ({# call webkit_dom_dom_window_get_menubar #} (toWindow self))) + +getPersonalbar :: + (MonadIO m, WindowClass self) => self -> m (Maybe BarProp) +getPersonalbar self + = liftIO + (maybeNull (makeNewGObject mkBarProp) + ({# call webkit_dom_dom_window_get_personalbar #} (toWindow self))) + +getScrollbars :: + (MonadIO m, WindowClass self) => self -> m (Maybe BarProp) +getScrollbars self + = liftIO + (maybeNull (makeNewGObject mkBarProp) + ({# call webkit_dom_dom_window_get_scrollbars #} (toWindow self))) + +getStatusbar :: + (MonadIO m, WindowClass self) => self -> m (Maybe BarProp) +getStatusbar self + = liftIO + (maybeNull (makeNewGObject mkBarProp) + ({# call webkit_dom_dom_window_get_statusbar #} (toWindow self))) + +getToolbar :: + (MonadIO m, WindowClass self) => self -> m (Maybe BarProp) +getToolbar self + = liftIO + (maybeNull (makeNewGObject mkBarProp) + ({# call webkit_dom_dom_window_get_toolbar #} (toWindow self))) +#endif + +getNavigator :: + (MonadIO m, WindowClass self) => self -> m (Maybe Navigator) +getNavigator self + = liftIO + (maybeNull (makeNewGObject mkNavigator) + ({# call webkit_dom_dom_window_get_navigator #} (toWindow self))) + +getClientInformation :: + (MonadIO m, WindowClass self) => self -> m (Maybe Navigator) +getClientInformation self + = liftIO + (maybeNull (makeNewGObject mkNavigator) + ({# call webkit_dom_dom_window_get_client_information #} + (toWindow self))) + +getFrameElement :: + (MonadIO m, WindowClass self) => self -> m (Maybe Element) +getFrameElement self + = liftIO + (maybeNull (makeNewGObject mkElement) + ({# call webkit_dom_dom_window_get_frame_element #} + (toWindow self))) + +getOffscreenBuffering :: + (MonadIO m, WindowClass self) => self -> m Bool +getOffscreenBuffering self + = liftIO + (toBool <$> + ({# call webkit_dom_dom_window_get_offscreen_buffering #} + (toWindow self))) + +getOuterHeight :: (MonadIO m, WindowClass self) => self -> m Int +getOuterHeight self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_dom_window_get_outer_height #} + (toWindow self))) + +getOuterWidth :: (MonadIO m, WindowClass self) => self -> m Int +getOuterWidth self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_dom_window_get_outer_width #} (toWindow self))) + +getInnerHeight :: (MonadIO m, WindowClass self) => self -> m Int +getInnerHeight self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_dom_window_get_inner_height #} + (toWindow self))) + +getInnerWidth :: (MonadIO m, WindowClass self) => self -> m Int +getInnerWidth self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_dom_window_get_inner_width #} (toWindow self))) + +getScreenX :: (MonadIO m, WindowClass self) => self -> m Int +getScreenX self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_dom_window_get_screen_x #} (toWindow self))) + +getScreenY :: (MonadIO m, WindowClass self) => self -> m Int +getScreenY self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_dom_window_get_screen_y #} (toWindow self))) + +getScreenLeft :: (MonadIO m, WindowClass self) => self -> m Int +getScreenLeft self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_dom_window_get_screen_left #} (toWindow self))) + +getScreenTop :: (MonadIO m, WindowClass self) => self -> m Int +getScreenTop self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_dom_window_get_screen_top #} (toWindow self))) + +getScrollX :: (MonadIO m, WindowClass self) => self -> m Int +getScrollX self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_dom_window_get_scroll_x #} (toWindow self))) + +getScrollY :: (MonadIO m, WindowClass self) => self -> m Int +getScrollY self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_dom_window_get_scroll_y #} (toWindow self))) + +getPageXOffset :: (MonadIO m, WindowClass self) => self -> m Int +getPageXOffset self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_dom_window_get_page_x_offset #} + (toWindow self))) + +getPageYOffset :: (MonadIO m, WindowClass self) => self -> m Int +getPageYOffset self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_dom_window_get_page_y_offset #} + (toWindow self))) + +getClosed :: (MonadIO m, WindowClass self) => self -> m Bool +getClosed self + = liftIO + (toBool <$> + ({# call webkit_dom_dom_window_get_closed #} (toWindow self))) + +getLength :: (MonadIO m, WindowClass self) => self -> m Word +getLength self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_dom_window_get_length #} (toWindow self))) + +setName :: + (MonadIO m, WindowClass self, GlibString string) => + self -> string -> m () +setName self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_dom_window_set_name #} (toWindow self) valPtr) + +getName :: + (MonadIO m, WindowClass self, GlibString string) => + self -> m string +getName self + = liftIO + (({# call webkit_dom_dom_window_get_name #} (toWindow self)) >>= + readUTFString) + +setStatus :: + (MonadIO m, WindowClass self, GlibString string) => + self -> string -> m () +setStatus self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_dom_window_set_status #} (toWindow self) valPtr) + +getStatus :: + (MonadIO m, WindowClass self, GlibString string) => + self -> m string +getStatus self + = liftIO + (({# call webkit_dom_dom_window_get_status #} (toWindow self)) >>= + readUTFString) + +setDefaultStatus :: + (MonadIO m, WindowClass self, GlibString string) => + self -> string -> m () +setDefaultStatus self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_dom_window_set_default_status #} (toWindow self) + valPtr) + +getDefaultStatus :: + (MonadIO m, WindowClass self, GlibString string) => + self -> m string +getDefaultStatus self + = liftIO + (({# call webkit_dom_dom_window_get_default_status #} + (toWindow self)) + >>= + readUTFString) + +getSelf :: + (MonadIO m, WindowClass self) => self -> m (Maybe Window) +getSelf self + = liftIO + (maybeNull (makeNewGObject mkWindow) + ({# call webkit_dom_dom_window_get_self #} (toWindow self))) + +getWindow :: + (MonadIO m, WindowClass self) => self -> m (Maybe Window) +getWindow self + = liftIO + (maybeNull (makeNewGObject mkWindow) + ({# call webkit_dom_dom_window_get_window #} (toWindow self))) + +getFrames :: + (MonadIO m, WindowClass self) => self -> m (Maybe Window) +getFrames self + = liftIO + (maybeNull (makeNewGObject mkWindow) + ({# call webkit_dom_dom_window_get_frames #} (toWindow self))) + +getOpener :: + (MonadIO m, WindowClass self) => self -> m (Maybe Window) +getOpener self + = liftIO + (maybeNull (makeNewGObject mkWindow) + ({# call webkit_dom_dom_window_get_opener #} (toWindow self))) + +getParent :: + (MonadIO m, WindowClass self) => self -> m (Maybe Window) +getParent self + = liftIO + (maybeNull (makeNewGObject mkWindow) + ({# call webkit_dom_dom_window_get_parent #} (toWindow self))) + +getTop :: (MonadIO m, WindowClass self) => self -> m (Maybe Window) +getTop self + = liftIO + (maybeNull (makeNewGObject mkWindow) + ({# call webkit_dom_dom_window_get_top #} (toWindow self))) + +getDocument :: + (MonadIO m, WindowClass self) => self -> m (Maybe Document) +getDocument self + = liftIO + (maybeNull (makeNewGObject mkDocument) + ({# call webkit_dom_dom_window_get_document #} (toWindow self))) + +getStyleMedia :: + (MonadIO m, WindowClass self) => self -> m (Maybe StyleMedia) +getStyleMedia self + = liftIO + (maybeNull (makeNewGObject mkStyleMedia) + ({# call webkit_dom_dom_window_get_style_media #} (toWindow self))) + +getDevicePixelRatio :: + (MonadIO m, WindowClass self) => self -> m Double +getDevicePixelRatio self + = liftIO + (realToFrac <$> + ({# call webkit_dom_dom_window_get_device_pixel_ratio #} + (toWindow self))) + +getApplicationCache :: + (MonadIO m, WindowClass self) => self -> m (Maybe ApplicationCache) +getApplicationCache self + = liftIO + (maybeNull (makeNewGObject mkApplicationCache) + ({# call webkit_dom_dom_window_get_application_cache #} + (toWindow self))) + +getSessionStorage :: + (MonadIO m, WindowClass self) => self -> m (Maybe Storage) +getSessionStorage self + = liftIO + (maybeNull (makeNewGObject mkStorage) + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_dom_window_get_session_storage #} + (toWindow self) + errorPtr_)) + +getLocalStorage :: + (MonadIO m, WindowClass self) => self -> m (Maybe Storage) +getLocalStorage self + = liftIO + (maybeNull (makeNewGObject mkStorage) + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_dom_window_get_local_storage #} (toWindow self) + errorPtr_)) + +#if WEBKIT_CHECK_VERSION(2,2,2) +getPerformance :: + (MonadIO m, WindowClass self) => self -> m (Maybe Performance) +getPerformance self + = liftIO + (maybeNull (makeNewGObject mkPerformance) + ({# call webkit_dom_dom_window_get_performance #} (toWindow self))) + +getCSS :: (MonadIO m, WindowClass self) => self -> m (Maybe CSS) +getCSS self + = liftIO + (maybeNull (makeNewGObject mkCSS) + ({# call webkit_dom_dom_window_get_css #} (toWindow self))) +#endif + +abort :: (WindowClass self) => EventName self UIEvent +abort = EventName "abort" + +beforeUnload :: (WindowClass self) => EventName self Event +beforeUnload = EventName "beforeunload" + +blurEvent :: (WindowClass self) => EventName self UIEvent +blurEvent = EventName "blur" + +canPlay :: (WindowClass self) => EventName self Event +canPlay = EventName "canplay" + +canPlayThrough :: (WindowClass self) => EventName self Event +canPlayThrough = EventName "canplaythrough" + +change :: (WindowClass self) => EventName self Event +change = EventName "change" + +click :: (WindowClass self) => EventName self MouseEvent +click = EventName "click" + +contextMenu :: (WindowClass self) => EventName self MouseEvent +contextMenu = EventName "contextmenu" + +dblClick :: (WindowClass self) => EventName self MouseEvent +dblClick = EventName "dblclick" + +drag :: (WindowClass self) => EventName self MouseEvent +drag = EventName "drag" + +dragEnd :: (WindowClass self) => EventName self MouseEvent +dragEnd = EventName "dragend" + +dragEnter :: (WindowClass self) => EventName self MouseEvent +dragEnter = EventName "dragenter" + +dragLeave :: (WindowClass self) => EventName self MouseEvent +dragLeave = EventName "dragleave" + +dragOver :: (WindowClass self) => EventName self MouseEvent +dragOver = EventName "dragover" + +dragStart :: (WindowClass self) => EventName self MouseEvent +dragStart = EventName "dragstart" + +drop :: (WindowClass self) => EventName self MouseEvent +drop = EventName "drop" + +durationChange :: (WindowClass self) => EventName self Event +durationChange = EventName "durationchange" + +emptied :: (WindowClass self) => EventName self Event +emptied = EventName "emptied" + +ended :: (WindowClass self) => EventName self Event +ended = EventName "ended" + +error :: (WindowClass self) => EventName self UIEvent +error = EventName "error" + +focusEvent :: (WindowClass self) => EventName self UIEvent +focusEvent = EventName "focus" + +hashChange :: (WindowClass self) => EventName self Event +hashChange = EventName "hashchange" + +input :: (WindowClass self) => EventName self Event +input = EventName "input" + +invalid :: (WindowClass self) => EventName self Event +invalid = EventName "invalid" + +#if WEBKIT_CHECK_VERSION(2,2,2) +keyDown :: (WindowClass self) => EventName self KeyboardEvent +keyDown = EventName "keydown" + +keyPress :: (WindowClass self) => EventName self KeyboardEvent +keyPress = EventName "keypress" + +keyUp :: (WindowClass self) => EventName self KeyboardEvent +keyUp = EventName "keyup" +#endif + +load :: (WindowClass self) => EventName self UIEvent +load = EventName "load" + +loadedData :: (WindowClass self) => EventName self Event +loadedData = EventName "loadeddata" + +loadedMetadata :: (WindowClass self) => EventName self Event +loadedMetadata = EventName "loadedmetadata" + +loadStart :: (WindowClass self) => EventName self Event +loadStart = EventName "loadstart" + +message :: (WindowClass self) => EventName self Event +message = EventName "message" + +mouseDown :: (WindowClass self) => EventName self MouseEvent +mouseDown = EventName "mousedown" + +mouseEnter :: (WindowClass self) => EventName self MouseEvent +mouseEnter = EventName "mouseenter" + +mouseLeave :: (WindowClass self) => EventName self MouseEvent +mouseLeave = EventName "mouseleave" + +mouseMove :: (WindowClass self) => EventName self MouseEvent +mouseMove = EventName "mousemove" + +mouseOut :: (WindowClass self) => EventName self MouseEvent +mouseOut = EventName "mouseout" + +mouseOver :: (WindowClass self) => EventName self MouseEvent +mouseOver = EventName "mouseover" + +mouseUp :: (WindowClass self) => EventName self MouseEvent +mouseUp = EventName "mouseup" + +mouseWheel :: (WindowClass self) => EventName self MouseEvent +mouseWheel = EventName "mousewheel" + +offline :: (WindowClass self) => EventName self Event +offline = EventName "offline" + +online :: (WindowClass self) => EventName self Event +online = EventName "online" + +pageHide :: (WindowClass self) => EventName self Event +pageHide = EventName "pagehide" + +pageShow :: (WindowClass self) => EventName self Event +pageShow = EventName "pageshow" + +pause :: (WindowClass self) => EventName self Event +pause = EventName "pause" + +play :: (WindowClass self) => EventName self Event +play = EventName "play" + +playing :: (WindowClass self) => EventName self Event +playing = EventName "playing" + +popState :: (WindowClass self) => EventName self Event +popState = EventName "popstate" + +progress :: (WindowClass self) => EventName self Event +progress = EventName "progress" + +rateChange :: (WindowClass self) => EventName self Event +rateChange = EventName "ratechange" + +resize :: (WindowClass self) => EventName self UIEvent +resize = EventName "resize" + +scrollEvent :: (WindowClass self) => EventName self UIEvent +scrollEvent = EventName "scroll" + +seeked :: (WindowClass self) => EventName self Event +seeked = EventName "seeked" + +seeking :: (WindowClass self) => EventName self Event +seeking = EventName "seeking" + +select :: (WindowClass self) => EventName self UIEvent +select = EventName "select" + +stalled :: (WindowClass self) => EventName self Event +stalled = EventName "stalled" + +storage :: (WindowClass self) => EventName self Event +storage = EventName "storage" + +submit :: (WindowClass self) => EventName self Event +submit = EventName "submit" + +suspend :: (WindowClass self) => EventName self Event +suspend = EventName "suspend" + +timeUpdate :: (WindowClass self) => EventName self Event +timeUpdate = EventName "timeupdate" + +unload :: (WindowClass self) => EventName self UIEvent +unload = EventName "unload" + +volumeChange :: (WindowClass self) => EventName self Event +volumeChange = EventName "volumechange" + +waiting :: (WindowClass self) => EventName self Event +waiting = EventName "waiting" + +#if WEBKIT_CHECK_VERSION(2,4,0) +wheel :: (WindowClass self) => EventName self WheelEvent +wheel = EventName "wheel" +#endif + +reset :: (WindowClass self) => EventName self Event +reset = EventName "reset" + +search :: (WindowClass self) => EventName self Event +search = EventName "search" + +webKitAnimationEnd :: (WindowClass self) => EventName self Event +webKitAnimationEnd = EventName "webkitanimationend" + +webKitAnimationIteration :: + (WindowClass self) => EventName self Event +webKitAnimationIteration = EventName "webkitanimationiteration" + +webKitAnimationStart :: (WindowClass self) => EventName self Event +webKitAnimationStart = EventName "webkitanimationstart" + +animationEnd :: (WindowClass self) => EventName self Event +animationEnd = EventName "animationend" + +animationIteration :: (WindowClass self) => EventName self Event +animationIteration = EventName "animationiteration" + +animationStart :: (WindowClass self) => EventName self Event +animationStart = EventName "animationstart" + +webKitTransitionEnd :: (WindowClass self) => EventName self Event +webKitTransitionEnd = EventName "webkittransitionend" + +transitionEnd :: (WindowClass self) => EventName self Event +transitionEnd = EventName "transitionend" + +touchStart :: (WindowClass self) => EventName self UIEvent +touchStart = EventName "touchstart" + +touchMove :: (WindowClass self) => EventName self UIEvent +touchMove = EventName "touchmove" + +touchEnd :: (WindowClass self) => EventName self UIEvent +touchEnd = EventName "touchend" + +touchCancel :: (WindowClass self) => EventName self UIEvent +touchCancel = EventName "touchcancel" + +gestureStart :: (WindowClass self) => EventName self UIEvent +gestureStart = EventName "gesturestart" + +gestureChange :: (WindowClass self) => EventName self UIEvent +gestureChange = EventName "gesturechange" + +gestureEnd :: (WindowClass self) => EventName self UIEvent +gestureEnd = EventName "gestureend" + +deviceMotion :: (WindowClass self) => EventName self Event +deviceMotion = EventName "devicemotion" + +deviceOrientation :: (WindowClass self) => EventName self Event +deviceOrientation = EventName "deviceorientation" + +webKitDeviceProximity :: (WindowClass self) => EventName self Event +webKitDeviceProximity = EventName "webkitdeviceproximity" + +webKitWillRevealBottom :: + (WindowClass self) => EventName self Event +webKitWillRevealBottom = EventName "webkitwillrevealbottom" + +webKitWillRevealLeft :: (WindowClass self) => EventName self Event +webKitWillRevealLeft = EventName "webkitwillrevealleft" + +webKitWillRevealRight :: (WindowClass self) => EventName self Event +webKitWillRevealRight = EventName "webkitwillrevealright" + +webKitWillRevealTop :: (WindowClass self) => EventName self Event +webKitWillRevealTop = EventName "webkitwillrevealtop" diff --git a/Graphics/UI/Gtk/WebKit/DOM/XPathExpression.chs b/Graphics/UI/Gtk/WebKit/DOM/XPathExpression.chs --- a/Graphics/UI/Gtk/WebKit/DOM/XPathExpression.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/XPathExpression.chs @@ -1,27 +1,40 @@ -module Graphics.UI.Gtk.WebKit.DOM.XPathExpression - (xPathExpressionEvaluate, XPathExpression, XPathExpressionClass, - castToXPathExpression, gTypeXPathExpression, toXPathExpression) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.XPathExpression( +evaluate, +XPathExpression, +castToXPathExpression, +gTypeXPathExpression, +XPathExpressionClass, +toXPathExpression, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -xPathExpressionEvaluate :: - (XPathExpressionClass self, NodeClass contextNode, - XPathResultClass inResult) => - self -> - Maybe contextNode -> - Word -> Maybe inResult -> IO (Maybe XPathResult) -xPathExpressionEvaluate self contextNode type' inResult - = maybeNull (makeNewGObject mkXPathResult) - (propagateGError $ - \ errorPtr_ -> - {# call webkit_dom_xpath_expression_evaluate #} - (toXPathExpression self) - (maybe (Node nullForeignPtr) toNode contextNode) - (fromIntegral type') - (maybe (XPathResult nullForeignPtr) toXPathResult inResult) - errorPtr_) +evaluate :: + (MonadIO m, XPathExpressionClass self, NodeClass contextNode, + XPathResultClass inResult) => + self -> + Maybe contextNode -> + Word -> Maybe inResult -> m (Maybe XPathResult) +evaluate self contextNode type' inResult + = liftIO + (maybeNull (makeNewGObject mkXPathResult) + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_xpath_expression_evaluate #} + (toXPathExpression self) + (maybe (Node nullForeignPtr) toNode contextNode) + (fromIntegral type') + (maybe (XPathResult nullForeignPtr) toXPathResult inResult) + errorPtr_)) diff --git a/Graphics/UI/Gtk/WebKit/DOM/XPathNSResolver.chs b/Graphics/UI/Gtk/WebKit/DOM/XPathNSResolver.chs --- a/Graphics/UI/Gtk/WebKit/DOM/XPathNSResolver.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/XPathNSResolver.chs @@ -1,22 +1,35 @@ -module Graphics.UI.Gtk.WebKit.DOM.XPathNSResolver - (xPathNSResolverLookupNamespaceURI, XPathNSResolver, - XPathNSResolverClass, castToXPathNSResolver, gTypeXPathNSResolver, - toXPathNSResolver) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.XPathNSResolver( +lookupNamespaceURI, +XPathNSResolver, +castToXPathNSResolver, +gTypeXPathNSResolver, +XPathNSResolverClass, +toXPathNSResolver, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -xPathNSResolverLookupNamespaceURI :: - (XPathNSResolverClass self) => self -> String -> IO String -xPathNSResolverLookupNamespaceURI self prefix - = (withUTFString prefix $ - \ prefixPtr -> - {# call webkit_dom_xpath_ns_resolver_lookup_namespace_uri #} - (toXPathNSResolver self) - prefixPtr) - >>= - readUTFString +lookupNamespaceURI :: + (MonadIO m, XPathNSResolverClass self, GlibString string) => + self -> string -> m (Maybe string) +lookupNamespaceURI self prefix + = liftIO + ((withUTFString prefix $ + \ prefixPtr -> + {# call webkit_dom_xpath_ns_resolver_lookup_namespace_uri #} + (toXPathNSResolver self) + prefixPtr) + >>= + maybePeek readUTFString) diff --git a/Graphics/UI/Gtk/WebKit/DOM/XPathResult.chs b/Graphics/UI/Gtk/WebKit/DOM/XPathResult.chs --- a/Graphics/UI/Gtk/WebKit/DOM/XPathResult.chs +++ b/Graphics/UI/Gtk/WebKit/DOM/XPathResult.chs @@ -1,114 +1,147 @@ -module Graphics.UI.Gtk.WebKit.DOM.XPathResult - (xPathResultIterateNext, xPathResultSnapshotItem, cANY_TYPE, - cNUMBER_TYPE, cSTRING_TYPE, cBOOLEAN_TYPE, - cUNORDERED_NODE_ITERATOR_TYPE, cORDERED_NODE_ITERATOR_TYPE, - cUNORDERED_NODE_SNAPSHOT_TYPE, cORDERED_NODE_SNAPSHOT_TYPE, - cANY_UNORDERED_NODE_TYPE, cFIRST_ORDERED_NODE_TYPE, - xPathResultGetResultType, xPathResultGetNumberValue, - xPathResultGetStringValue, xPathResultGetBooleanValue, - xPathResultGetSingleNodeValue, xPathResultGetInvalidIteratorState, - xPathResultGetSnapshotLength, XPathResult, XPathResultClass, - castToXPathResult, gTypeXPathResult, toXPathResult) - where -import System.Glib.FFI -import System.Glib.UTFString -import Control.Applicative -{#import Graphics.UI.Gtk.WebKit.Types#} +module Graphics.UI.Gtk.WebKit.DOM.XPathResult( +iterateNext, +snapshotItem, +pattern ANY_TYPE, +pattern NUMBER_TYPE, +pattern STRING_TYPE, +pattern BOOLEAN_TYPE, +pattern UNORDERED_NODE_ITERATOR_TYPE, +pattern ORDERED_NODE_ITERATOR_TYPE, +pattern UNORDERED_NODE_SNAPSHOT_TYPE, +pattern ORDERED_NODE_SNAPSHOT_TYPE, +pattern ANY_UNORDERED_NODE_TYPE, +pattern FIRST_ORDERED_NODE_TYPE, +getResultType, +getNumberValue, +getStringValue, +getBooleanValue, +getSingleNodeValue, +getInvalidIteratorState, +getSnapshotLength, +XPathResult, +castToXPathResult, +gTypeXPathResult, +XPathResultClass, +toXPathResult, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + -xPathResultIterateNext :: - (XPathResultClass self) => self -> IO (Maybe Node) -xPathResultIterateNext self - = maybeNull (makeNewGObject mkNode) - (propagateGError $ - \ errorPtr_ -> - {# call webkit_dom_xpath_result_iterate_next #} - (toXPathResult self) - errorPtr_) +iterateNext :: + (MonadIO m, XPathResultClass self) => self -> m (Maybe Node) +iterateNext self + = liftIO + (maybeNull (makeNewGObject mkNode) + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_xpath_result_iterate_next #} + (toXPathResult self) + errorPtr_)) -xPathResultSnapshotItem :: - (XPathResultClass self) => self -> Word -> IO (Maybe Node) -xPathResultSnapshotItem self index - = maybeNull (makeNewGObject mkNode) - (propagateGError $ - \ errorPtr_ -> - {# call webkit_dom_xpath_result_snapshot_item #} - (toXPathResult self) - (fromIntegral index) - errorPtr_) -cANY_TYPE = 0 -cNUMBER_TYPE = 1 -cSTRING_TYPE = 2 -cBOOLEAN_TYPE = 3 -cUNORDERED_NODE_ITERATOR_TYPE = 4 -cORDERED_NODE_ITERATOR_TYPE = 5 -cUNORDERED_NODE_SNAPSHOT_TYPE = 6 -cORDERED_NODE_SNAPSHOT_TYPE = 7 -cANY_UNORDERED_NODE_TYPE = 8 -cFIRST_ORDERED_NODE_TYPE = 9 +snapshotItem :: + (MonadIO m, XPathResultClass self) => + self -> Word -> m (Maybe Node) +snapshotItem self index + = liftIO + (maybeNull (makeNewGObject mkNode) + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_xpath_result_snapshot_item #} + (toXPathResult self) + (fromIntegral index) + errorPtr_)) +pattern ANY_TYPE = 0 +pattern NUMBER_TYPE = 1 +pattern STRING_TYPE = 2 +pattern BOOLEAN_TYPE = 3 +pattern UNORDERED_NODE_ITERATOR_TYPE = 4 +pattern ORDERED_NODE_ITERATOR_TYPE = 5 +pattern UNORDERED_NODE_SNAPSHOT_TYPE = 6 +pattern ORDERED_NODE_SNAPSHOT_TYPE = 7 +pattern ANY_UNORDERED_NODE_TYPE = 8 +pattern FIRST_ORDERED_NODE_TYPE = 9 -xPathResultGetResultType :: - (XPathResultClass self) => self -> IO Word -xPathResultGetResultType self - = fromIntegral <$> - ({# call webkit_dom_xpath_result_get_result_type #} - (toXPathResult self)) +getResultType :: + (MonadIO m, XPathResultClass self) => self -> m Word +getResultType self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_xpath_result_get_result_type #} + (toXPathResult self))) -xPathResultGetNumberValue :: - (XPathResultClass self) => self -> IO Double -xPathResultGetNumberValue self - = realToFrac <$> - (propagateGError $ - \ errorPtr_ -> - {# call webkit_dom_xpath_result_get_number_value #} - (toXPathResult self) - errorPtr_) +getNumberValue :: + (MonadIO m, XPathResultClass self) => self -> m Double +getNumberValue self + = liftIO + (realToFrac <$> + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_xpath_result_get_number_value #} + (toXPathResult self) + errorPtr_)) -xPathResultGetStringValue :: - (XPathResultClass self) => self -> IO String -xPathResultGetStringValue self - = (propagateGError $ - \ errorPtr_ -> - {# call webkit_dom_xpath_result_get_string_value #} - (toXPathResult self) - errorPtr_) - >>= - readUTFString +getStringValue :: + (MonadIO m, XPathResultClass self, GlibString string) => + self -> m string +getStringValue self + = liftIO + ((propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_xpath_result_get_string_value #} + (toXPathResult self) + errorPtr_) + >>= + readUTFString) -xPathResultGetBooleanValue :: - (XPathResultClass self) => self -> IO Bool -xPathResultGetBooleanValue self - = toBool <$> - (propagateGError $ - \ errorPtr_ -> - {# call webkit_dom_xpath_result_get_boolean_value #} - (toXPathResult self) - errorPtr_) +getBooleanValue :: + (MonadIO m, XPathResultClass self) => self -> m Bool +getBooleanValue self + = liftIO + (toBool <$> + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_xpath_result_get_boolean_value #} + (toXPathResult self) + errorPtr_)) -xPathResultGetSingleNodeValue :: - (XPathResultClass self) => self -> IO (Maybe Node) -xPathResultGetSingleNodeValue self - = maybeNull (makeNewGObject mkNode) - (propagateGError $ - \ errorPtr_ -> - {# call webkit_dom_xpath_result_get_single_node_value #} - (toXPathResult self) - errorPtr_) +getSingleNodeValue :: + (MonadIO m, XPathResultClass self) => self -> m (Maybe Node) +getSingleNodeValue self + = liftIO + (maybeNull (makeNewGObject mkNode) + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_xpath_result_get_single_node_value #} + (toXPathResult self) + errorPtr_)) -xPathResultGetInvalidIteratorState :: - (XPathResultClass self) => self -> IO Bool -xPathResultGetInvalidIteratorState self - = toBool <$> - ({# call webkit_dom_xpath_result_get_invalid_iterator_state #} - (toXPathResult self)) +getInvalidIteratorState :: + (MonadIO m, XPathResultClass self) => self -> m Bool +getInvalidIteratorState self + = liftIO + (toBool <$> + ({# call webkit_dom_xpath_result_get_invalid_iterator_state #} + (toXPathResult self))) -xPathResultGetSnapshotLength :: - (XPathResultClass self) => self -> IO Word -xPathResultGetSnapshotLength self - = fromIntegral <$> - (propagateGError $ - \ errorPtr_ -> - {# call webkit_dom_xpath_result_get_snapshot_length #} - (toXPathResult self) - errorPtr_) +getSnapshotLength :: + (MonadIO m, XPathResultClass self) => self -> m Word +getSnapshotLength self + = liftIO + (fromIntegral <$> + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_xpath_result_get_snapshot_length #} + (toXPathResult self) + errorPtr_)) diff --git a/Graphics/UI/Gtk/WebKit/Download.chs b/Graphics/UI/Gtk/WebKit/Download.chs --- a/Graphics/UI/Gtk/WebKit/Download.chs +++ b/Graphics/UI/Gtk/WebKit/Download.chs @@ -5,7 +5,7 @@ -- Author : Cjacker Huang -- Copyright : (c) 2009 Cjacker Huang -- Copyright : (c) 2010 Andy Stewart --- +-- -- This library is free software; you can redistribute it and/or -- modify it under the terms of the GNU Lesser General Public -- License as published by the Free Software Foundation; either @@ -21,7 +21,7 @@ -- Stability : provisional -- Portability : portable (depends on GHC) -- --- Object used to communicate with the application when downloading +-- Object used to communicate with the application when downloading ----------------------------------------------------------------------------- module Graphics.UI.Gtk.WebKit.Download ( @@ -79,8 +79,8 @@ import System.Glib.FFI import System.Glib.UTFString import System.Glib.GList -import System.Glib.GError -import System.Glib.Attributes +import System.Glib.GError +import System.Glib.Attributes as G import System.Glib.Properties import Graphics.UI.Gtk.Gdk.Events @@ -105,7 +105,7 @@ -- -- Object used to communicate with the application when downloading. downloadNew :: NetworkRequestClass request => request -> IO Download -downloadNew nr = +downloadNew nr = wrapNewGObject mkDownload $ {#call download_new#} (toNetworkRequest nr) -- | Initiates the 'Download'. @@ -127,14 +127,14 @@ -- | Retrieves the URI from 'Download' which is being downloaded. downloadGetUri:: - DownloadClass self => self - -> IO (Maybe String) -- ^ the uri or @Nothing@ in case of failed -downloadGetUri dl = + (DownloadClass self, GlibString string) => self + -> IO (Maybe string) -- ^ the uri or @Nothing@ in case of failed +downloadGetUri dl = {#call download_get_uri#} (toDownload dl) - >>= maybePeek peekCString + >>= maybePeek peekUTFString -- | Retrieves the 'NetworkRequest' that backs the download process. -downloadGetNetworkRequest :: +downloadGetNetworkRequest :: DownloadClass self => self -> IO NetworkRequest downloadGetNetworkRequest dl = @@ -146,39 +146,39 @@ -- * Since 1.1.16 downloadGetNetworkResponse :: DownloadClass self => self - -> IO NetworkResponse -downloadGetNetworkResponse dl = + -> IO NetworkResponse +downloadGetNetworkResponse dl = makeNewGObject mkNetworkResponse $ {#call download_get_network_response#} (toDownload dl) #endif -- | Retrieves the filename that was suggested by the server, -- or the one derived from the URI. -downloadGetSuggestedFilename :: - DownloadClass self => self - -> IO (Maybe String) -- ^ the suggested filename or @Nothing@ in case of failed +downloadGetSuggestedFilename :: + (DownloadClass self, GlibString string) => self + -> IO (Maybe string) -- ^ the suggested filename or @Nothing@ in case of failed downloadGetSuggestedFilename dl = - {#call download_get_suggested_filename#} (toDownload dl) >>= maybePeek peekCString + {#call download_get_suggested_filename#} (toDownload dl) >>= maybePeek peekUTFString -- | Obtains the URI to which the downloaded file will be written. -- --- It is set by Application before call 'downloadStart' -downloadGetDestinationUri :: - DownloadClass self => self - -> IO (Maybe String) +-- It is set by Application before call 'downloadStart' +downloadGetDestinationUri :: + (DownloadClass self, GlibString string) => self + -> IO (Maybe string) downloadGetDestinationUri dl = - {#call download_get_destination_uri#} (toDownload dl) >>= maybePeek peekCString + {#call download_get_destination_uri#} (toDownload dl) >>= maybePeek peekUTFString -- | Defines the URI that should be used to save the downloaded file to. -downloadSetDestinationUri :: - DownloadClass self => self - -> String -- ^ @destination_uri@ - the destination URI +downloadSetDestinationUri :: + (DownloadClass self, GlibString string) => self + -> string -- ^ @destination_uri@ - the destination URI -> IO() downloadSetDestinationUri dl dest = - withCString dest $ \destPtr -> + withUTFString dest $ \destPtr -> {#call download_set_destination_uri#} (toDownload dl) destPtr -- |Determines the current progress of the 'Download' -downloadGetProgress :: +downloadGetProgress :: DownloadClass self => self -> IO Double -- ^ a 'Double' ranging from 0.0 to 1.0 downloadGetProgress dl = @@ -198,27 +198,27 @@ -- |Returns the excepted total size of the download. -- -- This is expected because the server may provide incorrect or missing --- Content-Length. +-- Content-Length. -- -- Notice that this may grow over time. -downloadGetTotalSize :: +downloadGetTotalSize :: DownloadClass self => self -> IO Int -- ^ the expected total size of the downloaded file. downloadGetTotalSize dl = liftM fromIntegral $ {#call download_get_total_size#} (toDownload dl) -- | Returns the current already downleaded size -downloadGetCurrentSize :: +downloadGetCurrentSize :: DownloadClass self => self -> IO Int -- ^ the already downloaded size. downloadGetCurrentSize dl = liftM fromIntegral $ {#call download_get_current_size#} (toDownload dl) -- | Obtains the current status of the 'Download' as 'DownloadStatus' -downloadGetStatus :: +downloadGetStatus :: DownloadClass self => self -> IO DownloadStatus -- ^ the current 'DownloadStatus' -downloadGetStatus dl = +downloadGetStatus dl = liftM (toEnum . fromIntegral) $ {#call download_get_status#} (toDownload dl) -- * Attibutes @@ -226,9 +226,9 @@ -- | The length of the data already downloaded -- -- Default value: 0 --- --- * Since 1.1.2 -- +-- * Since 1.1.2 +-- currentSize :: DownloadClass self => ReadAttr self Int currentSize = readAttr downloadGetCurrentSize @@ -237,14 +237,14 @@ -- Default value: \"\" -- -- * Since 1.1.2 -destinationUri :: DownloadClass self => Attr self (Maybe String) +destinationUri :: (DownloadClass self, GlibString string) => G.Attr self (Maybe string) destinationUri = newAttrFromMaybeStringProperty "destination-uri" -- | The NetworkRequest instance associated with the download. -- -- * Since 1.1.2 -networkRequest :: DownloadClass self => Attr self NetworkRequest -networkRequest = +networkRequest :: DownloadClass self => G.Attr self NetworkRequest +networkRequest = newAttrFromObjectProperty "network-request" {#call pure webkit_network_request_get_type#} @@ -252,15 +252,15 @@ -- | The NetworkResponse instance associated with the download. -- -- * Since 1.1.16 -networkResponse :: DownloadClass self => Attr self NetworkResponse -networkResponse = +networkResponse :: DownloadClass self => G.Attr self NetworkResponse +networkResponse = newAttrFromObjectProperty "network-response" {#call pure webkit_network_response_get_type#} #endif --- | Determines the current progress of the download. --- Notice that, although the progress changes are reported as soon as possible, --- the emission of the notify signal for this property is throttled, for the benefit of download managers. +-- | Determines the current progress of the download. +-- Notice that, although the progress changes are reported as soon as possible, +-- the emission of the notify signal for this property is throttled, for the benefit of download managers. -- If you care about every update, use 'Download' : currentSize. -- -- Allowed values: [0,1] @@ -284,7 +284,7 @@ -- Default value: \"\" -- -- * Since 1.1.2 -suggestedFilename :: DownloadClass self => ReadAttr self (Maybe String) +suggestedFilename :: (DownloadClass self, GlibString string) => ReadAttr self (Maybe string) suggestedFilename = readAttr downloadGetSuggestedFilename -- | The total size of the file @@ -297,14 +297,14 @@ -- * Signals --- | Emitted when download is interrupted either by user action or by network errors, +-- | Emitted when download is interrupted either by user action or by network errors, -- errorDetail will take any value of 'DownloadError'. -- --- 'download': the object on which the signal is emitted --- 'errorCode': the corresponding error code --- 'errorDetail': detailed error code for the error, see 'DownloadError' --- 'reason': a string describing the error --- +-- 'download': the object on which the signal is emitted +-- 'errorCode': the corresponding error code +-- 'errorDetail': detailed error code for the error, see 'DownloadError' +-- 'reason': a string describing the error +-- -- Since 1.1.2 -downloadError :: DownloadClass self => Signal self (Int -> Int -> String -> IO Bool) -downloadError = Signal (connect_INT_INT_STRING__BOOL "error") +downloadError :: (DownloadClass self, GlibString string) => Signal self (Int -> Int -> string -> IO Bool) +downloadError = Signal (connect_INT_INT_GLIBSTRING__BOOL "error") diff --git a/Graphics/UI/Gtk/WebKit/GtkInternals.hs b/Graphics/UI/Gtk/WebKit/GtkInternals.hs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/GtkInternals.hs @@ -0,0 +1,11 @@ +{-# LANGUAGE CPP #-} +module Graphics.UI.Gtk.WebKit.GtkInternals ( + module Graphics.UI.GtkInternals +) where + +import Graphics.UI.GtkInternals (GObjectClass(..), GObject(..), unGObject, toGObject, +#ifdef MIN_VERSION_gtk + ObjectClass(..), Object(..), unObject, toObject, +#endif + objectUnrefFromMainloop, ContainerClass(..), WidgetClass(..), makeNewGObject, Pixbuf, mkPixbuf, + mkTargetList, Adjustment, IMContext, Widget) diff --git a/Graphics/UI/Gtk/WebKit/NetworkRequest.chs b/Graphics/UI/Gtk/WebKit/NetworkRequest.chs --- a/Graphics/UI/Gtk/WebKit/NetworkRequest.chs +++ b/Graphics/UI/Gtk/WebKit/NetworkRequest.chs @@ -65,10 +65,11 @@ -- It is used whenever WebKit wants to provide information -- about a request that will be sent, or has been sent. networkRequestNew :: - String -- ^ @uri@ - the uri of the request + GlibString string + => string -- ^ @uri@ - the uri of the request -> IO NetworkRequest networkRequestNew uri = - withCString uri $ \uriPtr -> + withUTFString uri $ \uriPtr -> wrapNewGObject mkNetworkRequest $ {#call network_request_new#} uriPtr @@ -76,11 +77,12 @@ -- | Set the URI of 'NetworkRequest'. -- networkRequestSetUri :: - NetworkRequestClass self => self - -> String -- ^ @uri@ - the uri will be set to the request. + GlibString string + => NetworkRequestClass self => self + -> string -- ^ @uri@ - the uri will be set to the request. -> IO() networkRequestSetUri networkrequest uri = - withCString uri $ \uriPtr -> + withUTFString uri $ \uriPtr -> {#call network_request_set_uri#} (toNetworkRequest networkrequest) uriPtr @@ -88,9 +90,10 @@ -- | Return the uri of 'NetworkRequest'. networkRequestGetUri :: - NetworkRequestClass self => self - -> IO (Maybe String) -- ^ the URI or @Nothing@ in case failed. + GlibString string + => NetworkRequestClass self => self + -> IO (Maybe string) -- ^ the URI or @Nothing@ in case failed. networkRequestGetUri networkrequest = {#call network_request_get_uri#} (toNetworkRequest networkrequest) >>= - maybePeek peekCString + maybePeek peekUTFString diff --git a/Graphics/UI/Gtk/WebKit/NetworkResponse.chs b/Graphics/UI/Gtk/WebKit/NetworkResponse.chs --- a/Graphics/UI/Gtk/WebKit/NetworkResponse.chs +++ b/Graphics/UI/Gtk/WebKit/NetworkResponse.chs @@ -41,7 +41,7 @@ import System.Glib.FFI import System.Glib.UTFString import System.Glib.GList -import System.Glib.GError +import System.Glib.GError import Graphics.UI.Gtk.Gdk.Events {#import Graphics.UI.Gtk.Abstract.Object#} (makeNewObject) @@ -55,23 +55,23 @@ -- | Set the URI of 'NetworkResponse'. -- -networkResponseSetUri :: - NetworkResponseClass self => self - -> String -- ^ @uri@ - the uri will be set to the response. +networkResponseSetUri :: + (NetworkResponseClass self, GlibString string) => self + -> string -- ^ @uri@ - the uri will be set to the response. -> IO() networkResponseSetUri response uri = - withCString uri $ \uriPtr -> - {#call network_response_set_uri#} + withUTFString uri $ \uriPtr -> + {#call network_response_set_uri#} (toNetworkResponse response) uriPtr -- | Return the uri of 'NetworkResponse'. -networkResponseGetUri :: - NetworkResponseClass self => self - -> IO (Maybe String) -- ^ the URI or @Nothing@ in case failed. -networkResponseGetUri response = - {#call network_response_get_uri#} - (toNetworkResponse response) >>= - maybePeek peekCString +networkResponseGetUri :: + (NetworkResponseClass self, GlibString string) => self + -> IO (Maybe string) -- ^ the URI or @Nothing@ in case failed. +networkResponseGetUri response = + {#call network_response_get_uri#} + (toNetworkResponse response) >>= + maybePeek peekUTFString diff --git a/Graphics/UI/Gtk/WebKit/SecurityOrigin.chs b/Graphics/UI/Gtk/WebKit/SecurityOrigin.chs --- a/Graphics/UI/Gtk/WebKit/SecurityOrigin.chs +++ b/Graphics/UI/Gtk/WebKit/SecurityOrigin.chs @@ -28,9 +28,9 @@ -- | WebKitSecurityOrigin is a representation of a security domain defined by web sites. An origin -- consists of a host name, a protocol, and a port number. Web sites with the same security origin can -- access each other's resources for client-side scripting or database access. --- +-- -- Use 'webFrameGetSecurityOrigin' to get the security origin of a WebKitWebFrame. --- +-- -- Database quotas and usages are also defined per security origin. The cumulative disk usage of an -- origin's databases may be retrieved with 'securityOriginGetWebDatabaseUsage'. An origin's -- quota can be adjusted with 'securityOriginSetWebDatabaseQuota'. @@ -39,7 +39,7 @@ SecurityOrigin, SecurityOriginClass, --- * Methods +-- * Methods securityOriginGetAllWebDatabases, securityOriginGetHost, securityOriginGetPort, @@ -54,7 +54,7 @@ import System.Glib.FFI import System.Glib.UTFString import System.Glib.GList -import System.Glib.GError +import System.Glib.GError import Graphics.UI.Gtk.Gdk.Events {#import Graphics.UI.Gtk.Abstract.Object#} (makeNewObject) @@ -68,7 +68,7 @@ -- | Returns the frame's security origin. securityOriginGetAllWebDatabases :: SecurityOriginClass self => self - -> IO [WebDatabase] + -> IO [WebDatabase] securityOriginGetAllWebDatabases so = do glist <- {#call security_origin_get_all_web_databases#} (toSecurityOrigin so) databasePtr <- fromGList glist @@ -76,10 +76,10 @@ -- | Returns the hostname for the security origin. securityOriginGetHost :: - SecurityOriginClass self => self - -> IO String + (SecurityOriginClass self, GlibString string) => self + -> IO string securityOriginGetHost so = - {#call security_origin_get_host#} (toSecurityOrigin so) >>= peekCString + {#call security_origin_get_host#} (toSecurityOrigin so) >>= peekUTFString -- | Returns the port for the security origin. securityOriginGetPort :: @@ -90,10 +90,10 @@ -- | Returns the protocol for the security origin. securityOriginGetProtocol :: - SecurityOriginClass self => self - -> IO String + (SecurityOriginClass self, GlibString string) => self + -> IO string securityOriginGetProtocol so = - {#call security_origin_get_protocol#} (toSecurityOrigin so) >>= peekCString + {#call security_origin_get_protocol#} (toSecurityOrigin so) >>= peekUTFString -- | Returns the quota for Web Database storage of the security origin in bytes. securityOriginGetWebDatabaseQuota :: @@ -101,14 +101,14 @@ -> IO Int securityOriginGetWebDatabaseQuota so = liftM fromIntegral $ {#call security_origin_get_web_database_quota#} (toSecurityOrigin so) - + -- | Returns the usage for Web Database storage of the security origin in bytes. securityOriginGetWebDatabaseUsage :: SecurityOriginClass self => self -> IO Int securityOriginGetWebDatabaseUsage so = liftM fromIntegral $ {#call security_origin_get_web_database_usage#} (toSecurityOrigin so) - + -- | Adjust the quota for Web Database storage of the security origin securityOriginSetWebDatabaseQuota :: SecurityOriginClass self => self diff --git a/Graphics/UI/Gtk/WebKit/Signals.chs b/Graphics/UI/Gtk/WebKit/Signals.chs --- a/Graphics/UI/Gtk/WebKit/Signals.chs +++ b/Graphics/UI/Gtk/WebKit/Signals.chs @@ -1,4 +1,5 @@ {-# OPTIONS_HADDOCK hide #-} +{-# OPTIONS_GHC -fno-warn-unused-imports #-} -- -*-haskell-*- -- -------------------- automatically generated file - do not edit ------------ -- Callback installers for the GIMP Toolkit (GTK) Binding for Haskell @@ -28,7 +29,7 @@ -- The object system in the second version of GTK is based on GObject from -- GLIB. This base class is rather primitive in that it only implements -- ref and unref methods (and others that are not interesting to us). If --- the marshall list mentions OBJECT it refers to an instance of this +-- the marshall list mentions OBJECT it refers to an instance of this -- GObject which is automatically wrapped with a ref and unref call. -- Structures which are not derived from GObject have to be passed as -- BOXED which gives the signal connect function a possibility to do the @@ -42,36 +43,38 @@ connect_PTR_PTR__NONE, connect_OBJECT__BOOL, - connect_OBJECT_STRING_BOXED__BOOL, + connect_OBJECT_GLIBSTRING_BOXED__BOOL, connect_OBJECT__PTR, - connect_INT_INT_STRING__BOOL, - connect_STRING_STRING_INT_STRING__BOOL, - connect_OBJECT_STRING__BOOL, - connect_OBJECT_STRING_STRING__BOOL, + connect_INT_INT_GLIBSTRING__BOOL, + connect_GLIBSTRING_GLIBSTRING_INT_GLIBSTRING__BOOL, + connect_OBJECT_GLIBSTRING__BOOL, + connect_OBJECT_GLIBSTRING_GLIBSTRING__BOOL, + connect_OBJECT_OBJECT__BOOL, connect_OBJECT_OBJECT_OBJECT_OBJECT__BOOL, - connect_OBJECT_OBJECT_STRING_OBJECT__BOOL, + connect_OBJECT_OBJECT_GLIBSTRING_OBJECT__BOOL, connect_OBJECT_OBJECT_OBJECT_OBJECT__NONE, connect_OBJECT_OBJECT_MOBJECT_MOBJECT__NONE, connect_ENUM_INT__BOOL, connect_NONE__BOOL, connect_NONE__NONE, - connect_MSTRING_MSTRING__NONE, - connect_OBJECT_STRING__NONE, + connect_MGLIBSTRING_MGLIBSTRING__NONE, + connect_OBJECT_GLIBSTRING__NONE, connect_OBJECT_OBJECT__NONE, - connect_STRING_STRING__NONE, + connect_GLIBSTRING_GLIBSTRING__NONE, connect_OBJECT__NONE, connect_INT__NONE, - connect_STRING__NONE, + connect_GLIBSTRING__NONE, ) where -import Control.Monad (liftM) +import Control.Monad (liftM) import System.Glib.FFI -import System.Glib.UTFString (peekUTFString,maybePeekUTFString) +import System.Glib.UTFString (peekUTFString,maybePeekUTFString,newUTFString) +import qualified System.Glib.UTFString as Glib import System.Glib.GError (failOnGError) {#import System.Glib.Signals#} -{#import System.Glib.GObject#} +{#import System.Glib.GObject#} import Graphics.UI.GtkInternals @@ -108,13 +111,13 @@ makeNewGObject (GObject, objectUnrefFromMainloop) (return obj1) >>= \obj1' -> user (unsafeCastGObject obj1') -connect_OBJECT_STRING_BOXED__BOOL :: - (GObjectClass a', GObjectClass obj) => SignalName -> +connect_OBJECT_GLIBSTRING_BOXED__BOOL :: + (GObjectClass a', Glib.GlibString b', GObjectClass obj) => SignalName -> (Ptr c' -> IO c) -> ConnectAfter -> obj -> - (a' -> String -> c -> IO Bool) -> + (a' -> b' -> c -> IO Bool) -> IO (ConnectId obj) -connect_OBJECT_STRING_BOXED__BOOL signal boxedPre3 after obj user = +connect_OBJECT_GLIBSTRING_BOXED__BOOL signal boxedPre3 after obj user = connectGeneric signal after obj action where action :: Ptr GObject -> Ptr GObject -> CString -> Ptr () -> IO Bool action _ obj1 str2 box3 = @@ -138,12 +141,12 @@ makeNewGObject (GObject, objectUnrefFromMainloop) (return obj1) >>= \obj1' -> user (unsafeCastGObject obj1') -connect_INT_INT_STRING__BOOL :: - GObjectClass obj => SignalName -> +connect_INT_INT_GLIBSTRING__BOOL :: + (Glib.GlibString c', GObjectClass obj) => SignalName -> ConnectAfter -> obj -> - (Int -> Int -> String -> IO Bool) -> + (Int -> Int -> c' -> IO Bool) -> IO (ConnectId obj) -connect_INT_INT_STRING__BOOL signal after obj user = +connect_INT_INT_GLIBSTRING__BOOL signal after obj user = connectGeneric signal after obj action where action :: Ptr GObject -> Int -> Int -> CString -> IO Bool action _ int1 int2 str3 = @@ -151,12 +154,12 @@ peekUTFString str3 >>= \str3' -> user int1 int2 str3' -connect_STRING_STRING_INT_STRING__BOOL :: - GObjectClass obj => SignalName -> +connect_GLIBSTRING_GLIBSTRING_INT_GLIBSTRING__BOOL :: + (Glib.GlibString a', Glib.GlibString b', Glib.GlibString d', GObjectClass obj) => SignalName -> ConnectAfter -> obj -> - (String -> String -> Int -> String -> IO Bool) -> + (a' -> b' -> Int -> d' -> IO Bool) -> IO (ConnectId obj) -connect_STRING_STRING_INT_STRING__BOOL signal after obj user = +connect_GLIBSTRING_GLIBSTRING_INT_GLIBSTRING__BOOL signal after obj user = connectGeneric signal after obj action where action :: Ptr GObject -> CString -> CString -> Int -> CString -> IO Bool action _ str1 str2 int3 str4 = @@ -166,12 +169,12 @@ peekUTFString str1 >>= \str1' -> user str1' str2' int3 str4' -connect_OBJECT_STRING__BOOL :: - (GObjectClass a', GObjectClass obj) => SignalName -> +connect_OBJECT_GLIBSTRING__BOOL :: + (GObjectClass a', Glib.GlibString b', GObjectClass obj) => SignalName -> ConnectAfter -> obj -> - (a' -> String -> IO Bool) -> + (a' -> b' -> IO Bool) -> IO (ConnectId obj) -connect_OBJECT_STRING__BOOL signal after obj user = +connect_OBJECT_GLIBSTRING__BOOL signal after obj user = connectGeneric signal after obj action where action :: Ptr GObject -> Ptr GObject -> CString -> IO Bool action _ obj1 str2 = @@ -180,12 +183,12 @@ makeNewGObject (GObject, objectUnrefFromMainloop) (return obj1) >>= \obj1' -> user (unsafeCastGObject obj1') str2' -connect_OBJECT_STRING_STRING__BOOL :: - (GObjectClass a', GObjectClass obj) => SignalName -> +connect_OBJECT_GLIBSTRING_GLIBSTRING__BOOL :: + (GObjectClass a', Glib.GlibString b', Glib.GlibString c', GObjectClass obj) => SignalName -> ConnectAfter -> obj -> - (a' -> String -> String -> IO Bool) -> + (a' -> b' -> c' -> IO Bool) -> IO (ConnectId obj) -connect_OBJECT_STRING_STRING__BOOL signal after obj user = +connect_OBJECT_GLIBSTRING_GLIBSTRING__BOOL signal after obj user = connectGeneric signal after obj action where action :: Ptr GObject -> Ptr GObject -> CString -> CString -> IO Bool action _ obj1 str2 str3 = @@ -195,6 +198,20 @@ makeNewGObject (GObject, objectUnrefFromMainloop) (return obj1) >>= \obj1' -> user (unsafeCastGObject obj1') str2' str3' +connect_OBJECT_OBJECT__BOOL :: + (GObjectClass a', GObjectClass b', GObjectClass obj) => SignalName -> + ConnectAfter -> obj -> + (a' -> b' -> IO Bool) -> + IO (ConnectId obj) +connect_OBJECT_OBJECT__BOOL signal after obj user = + connectGeneric signal after obj action + where action :: Ptr GObject -> Ptr GObject -> Ptr GObject -> IO Bool + action _ obj1 obj2 = + failOnGError $ + makeNewGObject (GObject, objectUnrefFromMainloop) (return obj2) >>= \obj2' -> + makeNewGObject (GObject, objectUnrefFromMainloop) (return obj1) >>= \obj1' -> + user (unsafeCastGObject obj1') (unsafeCastGObject obj2') + connect_OBJECT_OBJECT_OBJECT_OBJECT__BOOL :: (GObjectClass a', GObjectClass b', GObjectClass c', GObjectClass d', GObjectClass obj) => SignalName -> ConnectAfter -> obj -> @@ -211,12 +228,12 @@ makeNewGObject (GObject, objectUnrefFromMainloop) (return obj1) >>= \obj1' -> user (unsafeCastGObject obj1') (unsafeCastGObject obj2') (unsafeCastGObject obj3') (unsafeCastGObject obj4') -connect_OBJECT_OBJECT_STRING_OBJECT__BOOL :: - (GObjectClass a', GObjectClass b', GObjectClass d', GObjectClass obj) => SignalName -> +connect_OBJECT_OBJECT_GLIBSTRING_OBJECT__BOOL :: + (GObjectClass a', GObjectClass b', Glib.GlibString c', GObjectClass d', GObjectClass obj) => SignalName -> ConnectAfter -> obj -> - (a' -> b' -> String -> d' -> IO Bool) -> + (a' -> b' -> c' -> d' -> IO Bool) -> IO (ConnectId obj) -connect_OBJECT_OBJECT_STRING_OBJECT__BOOL signal after obj user = +connect_OBJECT_OBJECT_GLIBSTRING_OBJECT__BOOL signal after obj user = connectGeneric signal after obj action where action :: Ptr GObject -> Ptr GObject -> Ptr GObject -> CString -> Ptr GObject -> IO Bool action _ obj1 obj2 str3 obj4 = @@ -295,12 +312,12 @@ failOnGError $ user -connect_MSTRING_MSTRING__NONE :: - GObjectClass obj => SignalName -> +connect_MGLIBSTRING_MGLIBSTRING__NONE :: + (Glib.GlibString a', Glib.GlibString b', GObjectClass obj) => SignalName -> ConnectAfter -> obj -> - (Maybe String -> Maybe String -> IO ()) -> + (Maybe a' -> Maybe b' -> IO ()) -> IO (ConnectId obj) -connect_MSTRING_MSTRING__NONE signal after obj user = +connect_MGLIBSTRING_MGLIBSTRING__NONE signal after obj user = connectGeneric signal after obj action where action :: Ptr GObject -> CString -> CString -> IO () action _ str1 str2 = @@ -309,12 +326,12 @@ maybePeekUTFString str1 >>= \str1' -> user str1' str2' -connect_OBJECT_STRING__NONE :: - (GObjectClass a', GObjectClass obj) => SignalName -> +connect_OBJECT_GLIBSTRING__NONE :: + (GObjectClass a', Glib.GlibString b', GObjectClass obj) => SignalName -> ConnectAfter -> obj -> - (a' -> String -> IO ()) -> + (a' -> b' -> IO ()) -> IO (ConnectId obj) -connect_OBJECT_STRING__NONE signal after obj user = +connect_OBJECT_GLIBSTRING__NONE signal after obj user = connectGeneric signal after obj action where action :: Ptr GObject -> Ptr GObject -> CString -> IO () action _ obj1 str2 = @@ -337,12 +354,12 @@ makeNewGObject (GObject, objectUnrefFromMainloop) (return obj1) >>= \obj1' -> user (unsafeCastGObject obj1') (unsafeCastGObject obj2') -connect_STRING_STRING__NONE :: - GObjectClass obj => SignalName -> +connect_GLIBSTRING_GLIBSTRING__NONE :: + (Glib.GlibString a', Glib.GlibString b', GObjectClass obj) => SignalName -> ConnectAfter -> obj -> - (String -> String -> IO ()) -> + (a' -> b' -> IO ()) -> IO (ConnectId obj) -connect_STRING_STRING__NONE signal after obj user = +connect_GLIBSTRING_GLIBSTRING__NONE signal after obj user = connectGeneric signal after obj action where action :: Ptr GObject -> CString -> CString -> IO () action _ str1 str2 = @@ -376,12 +393,12 @@ failOnGError $ user int1 -connect_STRING__NONE :: - GObjectClass obj => SignalName -> +connect_GLIBSTRING__NONE :: + (Glib.GlibString a', GObjectClass obj) => SignalName -> ConnectAfter -> obj -> - (String -> IO ()) -> + (a' -> IO ()) -> IO (ConnectId obj) -connect_STRING__NONE signal after obj user = +connect_GLIBSTRING__NONE signal after obj user = connectGeneric signal after obj action where action :: Ptr GObject -> CString -> IO () action _ str1 = diff --git a/Graphics/UI/Gtk/WebKit/Types.chs b/Graphics/UI/Gtk/WebKit/Types.chs --- a/Graphics/UI/Gtk/WebKit/Types.chs +++ b/Graphics/UI/Gtk/WebKit/Types.chs @@ -1,4234 +1,4689 @@ {-# LANGUAGE CPP #-} {-# OPTIONS_HADDOCK hide #-} --- -*-haskell-*- --- -------------------- automatically generated file - do not edit ---------- --- Object hierarchy for the GIMP Toolkit (GTK) Binding for Haskell --- --- Author : Axel Simon --- --- Copyright (C) 2001-2005 Axel Simon --- --- This library is free software; you can redistribute it and/or --- modify it under the terms of the GNU Lesser General Public --- License as published by the Free Software Foundation; either --- version 2.1 of the License, or (at your option) any later version. --- --- This library is distributed in the hope that it will be useful, --- but WITHOUT ANY WARRANTY; without even the implied warranty of --- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU --- Lesser General Public License for more details. --- --- #hide - --- | --- Maintainer : gtk2hs-users@lists.sourceforge.net --- Stability : provisional --- Portability : portable (depends on GHC) --- --- This file reflects the Gtk+ object hierarchy in terms of Haskell classes. --- --- Note: the mk... functions were originally meant to simply be an alias --- for the constructor. However, in order to communicate the destructor --- of an object to objectNew, the mk... functions are now a tuple containing --- Haskell constructor and the destructor function pointer. This hack avoids --- changing all modules that simply pass mk... to objectNew. --- -module Graphics.UI.Gtk.WebKit.Types ( - - module Graphics.UI.GtkInternals, - WebView(WebView), WebViewClass, - toWebView, - mkWebView, unWebView, - castToWebView, gTypeWebView, - WebFrame(WebFrame), WebFrameClass, - toWebFrame, - mkWebFrame, unWebFrame, - castToWebFrame, gTypeWebFrame, - WebSettings(WebSettings), WebSettingsClass, - toWebSettings, - mkWebSettings, unWebSettings, - castToWebSettings, gTypeWebSettings, - NetworkRequest(NetworkRequest), NetworkRequestClass, - toNetworkRequest, - mkNetworkRequest, unNetworkRequest, - castToNetworkRequest, gTypeNetworkRequest, - NetworkResponse(NetworkResponse), NetworkResponseClass, - toNetworkResponse, - mkNetworkResponse, unNetworkResponse, - castToNetworkResponse, gTypeNetworkResponse, - Download(Download), DownloadClass, - toDownload, - mkDownload, unDownload, - castToDownload, gTypeDownload, - WebBackForwardList(WebBackForwardList), WebBackForwardListClass, - toWebBackForwardList, - mkWebBackForwardList, unWebBackForwardList, - castToWebBackForwardList, gTypeWebBackForwardList, - WebHistoryItem(WebHistoryItem), WebHistoryItemClass, - toWebHistoryItem, - mkWebHistoryItem, unWebHistoryItem, - castToWebHistoryItem, gTypeWebHistoryItem, - WebInspector(WebInspector), WebInspectorClass, - toWebInspector, - mkWebInspector, unWebInspector, - castToWebInspector, gTypeWebInspector, - HitTestResult(HitTestResult), HitTestResultClass, - toHitTestResult, - mkHitTestResult, unHitTestResult, - castToHitTestResult, gTypeHitTestResult, - SecurityOrigin(SecurityOrigin), SecurityOriginClass, - toSecurityOrigin, - mkSecurityOrigin, unSecurityOrigin, - castToSecurityOrigin, gTypeSecurityOrigin, - SoupAuthDialog(SoupAuthDialog), SoupAuthDialogClass, - toSoupAuthDialog, - mkSoupAuthDialog, unSoupAuthDialog, - castToSoupAuthDialog, gTypeSoupAuthDialog, - WebDatabase(WebDatabase), WebDatabaseClass, - toWebDatabase, - mkWebDatabase, unWebDatabase, - castToWebDatabase, gTypeWebDatabase, - WebDataSource(WebDataSource), WebDataSourceClass, - toWebDataSource, - mkWebDataSource, unWebDataSource, - castToWebDataSource, gTypeWebDataSource, - WebNavigationAction(WebNavigationAction), WebNavigationActionClass, - toWebNavigationAction, - mkWebNavigationAction, unWebNavigationAction, - castToWebNavigationAction, gTypeWebNavigationAction, - WebPolicyDecision(WebPolicyDecision), WebPolicyDecisionClass, - toWebPolicyDecision, - mkWebPolicyDecision, unWebPolicyDecision, - castToWebPolicyDecision, gTypeWebPolicyDecision, - WebResource(WebResource), WebResourceClass, - toWebResource, - mkWebResource, unWebResource, - castToWebResource, gTypeWebResource, - WebWindowFeatures(WebWindowFeatures), WebWindowFeaturesClass, - toWebWindowFeatures, - mkWebWindowFeatures, unWebWindowFeatures, - castToWebWindowFeatures, gTypeWebWindowFeatures, - GeolocationPolicyDecision(GeolocationPolicyDecision), GeolocationPolicyDecisionClass, - toGeolocationPolicyDecision, - mkGeolocationPolicyDecision, unGeolocationPolicyDecision, - castToGeolocationPolicyDecision, gTypeGeolocationPolicyDecision, - BarProp(BarProp), BarPropClass, - toBarProp, - mkBarProp, unBarProp, - castToBarProp, gTypeBarProp, - Blob(Blob), BlobClass, - toBlob, - mkBlob, unBlob, - castToBlob, gTypeBlob, - File(File), FileClass, - toFile, - mkFile, unFile, - castToFile, gTypeFile, - CSSRule(CSSRule), CSSRuleClass, - toCSSRule, - mkCSSRule, unCSSRule, - castToCSSRule, gTypeCSSRule, - CSSRuleList(CSSRuleList), CSSRuleListClass, - toCSSRuleList, - mkCSSRuleList, unCSSRuleList, - castToCSSRuleList, gTypeCSSRuleList, - CSSStyleDeclaration(CSSStyleDeclaration), CSSStyleDeclarationClass, - toCSSStyleDeclaration, - mkCSSStyleDeclaration, unCSSStyleDeclaration, - castToCSSStyleDeclaration, gTypeCSSStyleDeclaration, - CSSValue(CSSValue), CSSValueClass, - toCSSValue, - mkCSSValue, unCSSValue, - castToCSSValue, gTypeCSSValue, - Console(Console), ConsoleClass, - toConsole, - mkConsole, unConsole, - castToConsole, gTypeConsole, - DOMApplicationCache(DOMApplicationCache), DOMApplicationCacheClass, - toDOMApplicationCache, - mkDOMApplicationCache, unDOMApplicationCache, - castToDOMApplicationCache, gTypeDOMApplicationCache, - DOMImplementation(DOMImplementation), DOMImplementationClass, - toDOMImplementation, - mkDOMImplementation, unDOMImplementation, - castToDOMImplementation, gTypeDOMImplementation, - DOMMimeType(DOMMimeType), DOMMimeTypeClass, - toDOMMimeType, - mkDOMMimeType, unDOMMimeType, - castToDOMMimeType, gTypeDOMMimeType, - DOMMimeTypeArray(DOMMimeTypeArray), DOMMimeTypeArrayClass, - toDOMMimeTypeArray, - mkDOMMimeTypeArray, unDOMMimeTypeArray, - castToDOMMimeTypeArray, gTypeDOMMimeTypeArray, - DOMNamedFlowCollection(DOMNamedFlowCollection), DOMNamedFlowCollectionClass, - toDOMNamedFlowCollection, - mkDOMNamedFlowCollection, unDOMNamedFlowCollection, - castToDOMNamedFlowCollection, gTypeDOMNamedFlowCollection, - DOMPlugin(DOMPlugin), DOMPluginClass, - toDOMPlugin, - mkDOMPlugin, unDOMPlugin, - castToDOMPlugin, gTypeDOMPlugin, - DOMPluginArray(DOMPluginArray), DOMPluginArrayClass, - toDOMPluginArray, - mkDOMPluginArray, unDOMPluginArray, - castToDOMPluginArray, gTypeDOMPluginArray, - DOMSecurityPolicy(DOMSecurityPolicy), DOMSecurityPolicyClass, - toDOMSecurityPolicy, - mkDOMSecurityPolicy, unDOMSecurityPolicy, - castToDOMSecurityPolicy, gTypeDOMSecurityPolicy, - DOMSelection(DOMSelection), DOMSelectionClass, - toDOMSelection, - mkDOMSelection, unDOMSelection, - castToDOMSelection, gTypeDOMSelection, - DOMStringList(DOMStringList), DOMStringListClass, - toDOMStringList, - mkDOMStringList, unDOMStringList, - castToDOMStringList, gTypeDOMStringList, - DOMTokenList(DOMTokenList), DOMTokenListClass, - toDOMTokenList, - mkDOMTokenList, unDOMTokenList, - castToDOMTokenList, gTypeDOMTokenList, - DOMSettableTokenList(DOMSettableTokenList), DOMSettableTokenListClass, - toDOMSettableTokenList, - mkDOMSettableTokenList, unDOMSettableTokenList, - castToDOMSettableTokenList, gTypeDOMSettableTokenList, - DOMWindow(DOMWindow), DOMWindowClass, - toDOMWindow, - mkDOMWindow, unDOMWindow, - castToDOMWindow, gTypeDOMWindow, - DOMWindowCSS(DOMWindowCSS), DOMWindowCSSClass, - toDOMWindowCSS, - mkDOMWindowCSS, unDOMWindowCSS, - castToDOMWindowCSS, gTypeDOMWindowCSS, - Event(Event), EventClass, - toEvent, - mkEvent, unEvent, - castToEvent, gTypeEvent, - UIEvent(UIEvent), UIEventClass, - toUIEvent, - mkUIEvent, unUIEvent, - castToUIEvent, gTypeUIEvent, - MouseEvent(MouseEvent), MouseEventClass, - toMouseEvent, - mkMouseEvent, unMouseEvent, - castToMouseEvent, gTypeMouseEvent, - KeyboardEvent(KeyboardEvent), KeyboardEventClass, - toKeyboardEvent, - mkKeyboardEvent, unKeyboardEvent, - castToKeyboardEvent, gTypeKeyboardEvent, - EventTarget(EventTarget), EventTargetClass, - toEventTarget, - mkEventTarget, unEventTarget, - castToEventTarget, gTypeEventTarget, - FileList(FileList), FileListClass, - toFileList, - mkFileList, unFileList, - castToFileList, gTypeFileList, - Geolocation(Geolocation), GeolocationClass, - toGeolocation, - mkGeolocation, unGeolocation, - castToGeolocation, gTypeGeolocation, - HTMLCollection(HTMLCollection), HTMLCollectionClass, - toHTMLCollection, - mkHTMLCollection, unHTMLCollection, - castToHTMLCollection, gTypeHTMLCollection, - HTMLOptionsCollection(HTMLOptionsCollection), HTMLOptionsCollectionClass, - toHTMLOptionsCollection, - mkHTMLOptionsCollection, unHTMLOptionsCollection, - castToHTMLOptionsCollection, gTypeHTMLOptionsCollection, - History(History), HistoryClass, - toHistory, - mkHistory, unHistory, - castToHistory, gTypeHistory, - Location(Location), LocationClass, - toLocation, - mkLocation, unLocation, - castToLocation, gTypeLocation, - MediaError(MediaError), MediaErrorClass, - toMediaError, - mkMediaError, unMediaError, - castToMediaError, gTypeMediaError, - MediaList(MediaList), MediaListClass, - toMediaList, - mkMediaList, unMediaList, - castToMediaList, gTypeMediaList, - MediaQueryList(MediaQueryList), MediaQueryListClass, - toMediaQueryList, - mkMediaQueryList, unMediaQueryList, - castToMediaQueryList, gTypeMediaQueryList, - MessagePort(MessagePort), MessagePortClass, - toMessagePort, - mkMessagePort, unMessagePort, - castToMessagePort, gTypeMessagePort, - NamedNodeMap(NamedNodeMap), NamedNodeMapClass, - toNamedNodeMap, - mkNamedNodeMap, unNamedNodeMap, - castToNamedNodeMap, gTypeNamedNodeMap, - Navigator(Navigator), NavigatorClass, - toNavigator, - mkNavigator, unNavigator, - castToNavigator, gTypeNavigator, - Node(Node), NodeClass, - toNode, - mkNode, unNode, - castToNode, gTypeNode, - DOMAttr(DOMAttr), DOMAttrClass, - toDOMAttr, - mkDOMAttr, unDOMAttr, - castToDOMAttr, gTypeDOMAttr, - CharacterData(CharacterData), CharacterDataClass, - toCharacterData, - mkCharacterData, unCharacterData, - castToCharacterData, gTypeCharacterData, - Comment(Comment), CommentClass, - toComment, - mkComment, unComment, - castToComment, gTypeComment, - Text(Text), TextClass, - toText, - mkText, unText, - castToText, gTypeText, - CDATASection(CDATASection), CDATASectionClass, - toCDATASection, - mkCDATASection, unCDATASection, - castToCDATASection, gTypeCDATASection, - Document(Document), DocumentClass, - toDocument, - mkDocument, unDocument, - castToDocument, gTypeDocument, - HTMLDocument(HTMLDocument), HTMLDocumentClass, - toHTMLDocument, - mkHTMLDocument, unHTMLDocument, - castToHTMLDocument, gTypeHTMLDocument, - DocumentFragment(DocumentFragment), DocumentFragmentClass, - toDocumentFragment, - mkDocumentFragment, unDocumentFragment, - castToDocumentFragment, gTypeDocumentFragment, - DocumentType(DocumentType), DocumentTypeClass, - toDocumentType, - mkDocumentType, unDocumentType, - castToDocumentType, gTypeDocumentType, - Element(Element), ElementClass, - toElement, - mkElement, unElement, - castToElement, gTypeElement, - HTMLElement(HTMLElement), HTMLElementClass, - toHTMLElement, - mkHTMLElement, unHTMLElement, - castToHTMLElement, gTypeHTMLElement, - HTMLAnchorElement(HTMLAnchorElement), HTMLAnchorElementClass, - toHTMLAnchorElement, - mkHTMLAnchorElement, unHTMLAnchorElement, - castToHTMLAnchorElement, gTypeHTMLAnchorElement, - HTMLAppletElement(HTMLAppletElement), HTMLAppletElementClass, - toHTMLAppletElement, - mkHTMLAppletElement, unHTMLAppletElement, - castToHTMLAppletElement, gTypeHTMLAppletElement, - HTMLAreaElement(HTMLAreaElement), HTMLAreaElementClass, - toHTMLAreaElement, - mkHTMLAreaElement, unHTMLAreaElement, - castToHTMLAreaElement, gTypeHTMLAreaElement, - HTMLBRElement(HTMLBRElement), HTMLBRElementClass, - toHTMLBRElement, - mkHTMLBRElement, unHTMLBRElement, - castToHTMLBRElement, gTypeHTMLBRElement, - HTMLBaseElement(HTMLBaseElement), HTMLBaseElementClass, - toHTMLBaseElement, - mkHTMLBaseElement, unHTMLBaseElement, - castToHTMLBaseElement, gTypeHTMLBaseElement, - HTMLBaseFontElement(HTMLBaseFontElement), HTMLBaseFontElementClass, - toHTMLBaseFontElement, - mkHTMLBaseFontElement, unHTMLBaseFontElement, - castToHTMLBaseFontElement, gTypeHTMLBaseFontElement, - HTMLBodyElement(HTMLBodyElement), HTMLBodyElementClass, - toHTMLBodyElement, - mkHTMLBodyElement, unHTMLBodyElement, - castToHTMLBodyElement, gTypeHTMLBodyElement, - HTMLButtonElement(HTMLButtonElement), HTMLButtonElementClass, - toHTMLButtonElement, - mkHTMLButtonElement, unHTMLButtonElement, - castToHTMLButtonElement, gTypeHTMLButtonElement, - HTMLCanvasElement(HTMLCanvasElement), HTMLCanvasElementClass, - toHTMLCanvasElement, - mkHTMLCanvasElement, unHTMLCanvasElement, - castToHTMLCanvasElement, gTypeHTMLCanvasElement, - HTMLDListElement(HTMLDListElement), HTMLDListElementClass, - toHTMLDListElement, - mkHTMLDListElement, unHTMLDListElement, - castToHTMLDListElement, gTypeHTMLDListElement, - HTMLDetailsElement(HTMLDetailsElement), HTMLDetailsElementClass, - toHTMLDetailsElement, - mkHTMLDetailsElement, unHTMLDetailsElement, - castToHTMLDetailsElement, gTypeHTMLDetailsElement, - HTMLDirectoryElement(HTMLDirectoryElement), HTMLDirectoryElementClass, - toHTMLDirectoryElement, - mkHTMLDirectoryElement, unHTMLDirectoryElement, - castToHTMLDirectoryElement, gTypeHTMLDirectoryElement, - HTMLDivElement(HTMLDivElement), HTMLDivElementClass, - toHTMLDivElement, - mkHTMLDivElement, unHTMLDivElement, - castToHTMLDivElement, gTypeHTMLDivElement, - HTMLEmbedElement(HTMLEmbedElement), HTMLEmbedElementClass, - toHTMLEmbedElement, - mkHTMLEmbedElement, unHTMLEmbedElement, - castToHTMLEmbedElement, gTypeHTMLEmbedElement, - HTMLFieldSetElement(HTMLFieldSetElement), HTMLFieldSetElementClass, - toHTMLFieldSetElement, - mkHTMLFieldSetElement, unHTMLFieldSetElement, - castToHTMLFieldSetElement, gTypeHTMLFieldSetElement, - HTMLFontElement(HTMLFontElement), HTMLFontElementClass, - toHTMLFontElement, - mkHTMLFontElement, unHTMLFontElement, - castToHTMLFontElement, gTypeHTMLFontElement, - HTMLFormElement(HTMLFormElement), HTMLFormElementClass, - toHTMLFormElement, - mkHTMLFormElement, unHTMLFormElement, - castToHTMLFormElement, gTypeHTMLFormElement, - HTMLFrameElement(HTMLFrameElement), HTMLFrameElementClass, - toHTMLFrameElement, - mkHTMLFrameElement, unHTMLFrameElement, - castToHTMLFrameElement, gTypeHTMLFrameElement, - HTMLFrameSetElement(HTMLFrameSetElement), HTMLFrameSetElementClass, - toHTMLFrameSetElement, - mkHTMLFrameSetElement, unHTMLFrameSetElement, - castToHTMLFrameSetElement, gTypeHTMLFrameSetElement, - HTMLHRElement(HTMLHRElement), HTMLHRElementClass, - toHTMLHRElement, - mkHTMLHRElement, unHTMLHRElement, - castToHTMLHRElement, gTypeHTMLHRElement, - HTMLHeadElement(HTMLHeadElement), HTMLHeadElementClass, - toHTMLHeadElement, - mkHTMLHeadElement, unHTMLHeadElement, - castToHTMLHeadElement, gTypeHTMLHeadElement, - HTMLHeadingElement(HTMLHeadingElement), HTMLHeadingElementClass, - toHTMLHeadingElement, - mkHTMLHeadingElement, unHTMLHeadingElement, - castToHTMLHeadingElement, gTypeHTMLHeadingElement, - HTMLHtmlElement(HTMLHtmlElement), HTMLHtmlElementClass, - toHTMLHtmlElement, - mkHTMLHtmlElement, unHTMLHtmlElement, - castToHTMLHtmlElement, gTypeHTMLHtmlElement, - HTMLIFrameElement(HTMLIFrameElement), HTMLIFrameElementClass, - toHTMLIFrameElement, - mkHTMLIFrameElement, unHTMLIFrameElement, - castToHTMLIFrameElement, gTypeHTMLIFrameElement, - HTMLImageElement(HTMLImageElement), HTMLImageElementClass, - toHTMLImageElement, - mkHTMLImageElement, unHTMLImageElement, - castToHTMLImageElement, gTypeHTMLImageElement, - HTMLInputElement(HTMLInputElement), HTMLInputElementClass, - toHTMLInputElement, - mkHTMLInputElement, unHTMLInputElement, - castToHTMLInputElement, gTypeHTMLInputElement, - HTMLKeygenElement(HTMLKeygenElement), HTMLKeygenElementClass, - toHTMLKeygenElement, - mkHTMLKeygenElement, unHTMLKeygenElement, - castToHTMLKeygenElement, gTypeHTMLKeygenElement, - HTMLLIElement(HTMLLIElement), HTMLLIElementClass, - toHTMLLIElement, - mkHTMLLIElement, unHTMLLIElement, - castToHTMLLIElement, gTypeHTMLLIElement, - HTMLLabelElement(HTMLLabelElement), HTMLLabelElementClass, - toHTMLLabelElement, - mkHTMLLabelElement, unHTMLLabelElement, - castToHTMLLabelElement, gTypeHTMLLabelElement, - HTMLLegendElement(HTMLLegendElement), HTMLLegendElementClass, - toHTMLLegendElement, - mkHTMLLegendElement, unHTMLLegendElement, - castToHTMLLegendElement, gTypeHTMLLegendElement, - HTMLLinkElement(HTMLLinkElement), HTMLLinkElementClass, - toHTMLLinkElement, - mkHTMLLinkElement, unHTMLLinkElement, - castToHTMLLinkElement, gTypeHTMLLinkElement, - HTMLMapElement(HTMLMapElement), HTMLMapElementClass, - toHTMLMapElement, - mkHTMLMapElement, unHTMLMapElement, - castToHTMLMapElement, gTypeHTMLMapElement, - HTMLMarqueeElement(HTMLMarqueeElement), HTMLMarqueeElementClass, - toHTMLMarqueeElement, - mkHTMLMarqueeElement, unHTMLMarqueeElement, - castToHTMLMarqueeElement, gTypeHTMLMarqueeElement, - HTMLMediaElement(HTMLMediaElement), HTMLMediaElementClass, - toHTMLMediaElement, - mkHTMLMediaElement, unHTMLMediaElement, - castToHTMLMediaElement, gTypeHTMLMediaElement, - HTMLAudioElement(HTMLAudioElement), HTMLAudioElementClass, - toHTMLAudioElement, - mkHTMLAudioElement, unHTMLAudioElement, - castToHTMLAudioElement, gTypeHTMLAudioElement, - HTMLVideoElement(HTMLVideoElement), HTMLVideoElementClass, - toHTMLVideoElement, - mkHTMLVideoElement, unHTMLVideoElement, - castToHTMLVideoElement, gTypeHTMLVideoElement, - HTMLMenuElement(HTMLMenuElement), HTMLMenuElementClass, - toHTMLMenuElement, - mkHTMLMenuElement, unHTMLMenuElement, - castToHTMLMenuElement, gTypeHTMLMenuElement, - HTMLMetaElement(HTMLMetaElement), HTMLMetaElementClass, - toHTMLMetaElement, - mkHTMLMetaElement, unHTMLMetaElement, - castToHTMLMetaElement, gTypeHTMLMetaElement, - HTMLModElement(HTMLModElement), HTMLModElementClass, - toHTMLModElement, - mkHTMLModElement, unHTMLModElement, - castToHTMLModElement, gTypeHTMLModElement, - HTMLOListElement(HTMLOListElement), HTMLOListElementClass, - toHTMLOListElement, - mkHTMLOListElement, unHTMLOListElement, - castToHTMLOListElement, gTypeHTMLOListElement, - HTMLObjectElement(HTMLObjectElement), HTMLObjectElementClass, - toHTMLObjectElement, - mkHTMLObjectElement, unHTMLObjectElement, - castToHTMLObjectElement, gTypeHTMLObjectElement, - HTMLOptGroupElement(HTMLOptGroupElement), HTMLOptGroupElementClass, - toHTMLOptGroupElement, - mkHTMLOptGroupElement, unHTMLOptGroupElement, - castToHTMLOptGroupElement, gTypeHTMLOptGroupElement, - HTMLOptionElement(HTMLOptionElement), HTMLOptionElementClass, - toHTMLOptionElement, - mkHTMLOptionElement, unHTMLOptionElement, - castToHTMLOptionElement, gTypeHTMLOptionElement, - HTMLParagraphElement(HTMLParagraphElement), HTMLParagraphElementClass, - toHTMLParagraphElement, - mkHTMLParagraphElement, unHTMLParagraphElement, - castToHTMLParagraphElement, gTypeHTMLParagraphElement, - HTMLParamElement(HTMLParamElement), HTMLParamElementClass, - toHTMLParamElement, - mkHTMLParamElement, unHTMLParamElement, - castToHTMLParamElement, gTypeHTMLParamElement, - HTMLPreElement(HTMLPreElement), HTMLPreElementClass, - toHTMLPreElement, - mkHTMLPreElement, unHTMLPreElement, - castToHTMLPreElement, gTypeHTMLPreElement, - HTMLQuoteElement(HTMLQuoteElement), HTMLQuoteElementClass, - toHTMLQuoteElement, - mkHTMLQuoteElement, unHTMLQuoteElement, - castToHTMLQuoteElement, gTypeHTMLQuoteElement, - HTMLScriptElement(HTMLScriptElement), HTMLScriptElementClass, - toHTMLScriptElement, - mkHTMLScriptElement, unHTMLScriptElement, - castToHTMLScriptElement, gTypeHTMLScriptElement, - HTMLSelectElement(HTMLSelectElement), HTMLSelectElementClass, - toHTMLSelectElement, - mkHTMLSelectElement, unHTMLSelectElement, - castToHTMLSelectElement, gTypeHTMLSelectElement, - HTMLStyleElement(HTMLStyleElement), HTMLStyleElementClass, - toHTMLStyleElement, - mkHTMLStyleElement, unHTMLStyleElement, - castToHTMLStyleElement, gTypeHTMLStyleElement, - HTMLTableCaptionElement(HTMLTableCaptionElement), HTMLTableCaptionElementClass, - toHTMLTableCaptionElement, - mkHTMLTableCaptionElement, unHTMLTableCaptionElement, - castToHTMLTableCaptionElement, gTypeHTMLTableCaptionElement, - HTMLTableCellElement(HTMLTableCellElement), HTMLTableCellElementClass, - toHTMLTableCellElement, - mkHTMLTableCellElement, unHTMLTableCellElement, - castToHTMLTableCellElement, gTypeHTMLTableCellElement, - HTMLTableColElement(HTMLTableColElement), HTMLTableColElementClass, - toHTMLTableColElement, - mkHTMLTableColElement, unHTMLTableColElement, - castToHTMLTableColElement, gTypeHTMLTableColElement, - HTMLTableElement(HTMLTableElement), HTMLTableElementClass, - toHTMLTableElement, - mkHTMLTableElement, unHTMLTableElement, - castToHTMLTableElement, gTypeHTMLTableElement, - HTMLTableRowElement(HTMLTableRowElement), HTMLTableRowElementClass, - toHTMLTableRowElement, - mkHTMLTableRowElement, unHTMLTableRowElement, - castToHTMLTableRowElement, gTypeHTMLTableRowElement, - HTMLTableSectionElement(HTMLTableSectionElement), HTMLTableSectionElementClass, - toHTMLTableSectionElement, - mkHTMLTableSectionElement, unHTMLTableSectionElement, - castToHTMLTableSectionElement, gTypeHTMLTableSectionElement, - HTMLTextAreaElement(HTMLTextAreaElement), HTMLTextAreaElementClass, - toHTMLTextAreaElement, - mkHTMLTextAreaElement, unHTMLTextAreaElement, - castToHTMLTextAreaElement, gTypeHTMLTextAreaElement, - HTMLTitleElement(HTMLTitleElement), HTMLTitleElementClass, - toHTMLTitleElement, - mkHTMLTitleElement, unHTMLTitleElement, - castToHTMLTitleElement, gTypeHTMLTitleElement, - HTMLUListElement(HTMLUListElement), HTMLUListElementClass, - toHTMLUListElement, - mkHTMLUListElement, unHTMLUListElement, - castToHTMLUListElement, gTypeHTMLUListElement, - EntityReference(EntityReference), EntityReferenceClass, - toEntityReference, - mkEntityReference, unEntityReference, - castToEntityReference, gTypeEntityReference, - ProcessingInstruction(ProcessingInstruction), ProcessingInstructionClass, - toProcessingInstruction, - mkProcessingInstruction, unProcessingInstruction, - castToProcessingInstruction, gTypeProcessingInstruction, - NodeFilter(NodeFilter), NodeFilterClass, - toNodeFilter, - mkNodeFilter, unNodeFilter, - castToNodeFilter, gTypeNodeFilter, - NodeIterator(NodeIterator), NodeIteratorClass, - toNodeIterator, - mkNodeIterator, unNodeIterator, - castToNodeIterator, gTypeNodeIterator, - NodeList(NodeList), NodeListClass, - toNodeList, - mkNodeList, unNodeList, - castToNodeList, gTypeNodeList, - DOMRange(DOMRange), DOMRangeClass, - toDOMRange, - mkDOMRange, unDOMRange, - castToDOMRange, gTypeDOMRange, - DOMScreen(DOMScreen), DOMScreenClass, - toDOMScreen, - mkDOMScreen, unDOMScreen, - castToDOMScreen, gTypeDOMScreen, - Storage(Storage), StorageClass, - toStorage, - mkStorage, unStorage, - castToStorage, gTypeStorage, - StorageInfo(StorageInfo), StorageInfoClass, - toStorageInfo, - mkStorageInfo, unStorageInfo, - castToStorageInfo, gTypeStorageInfo, - StyleMedia(StyleMedia), StyleMediaClass, - toStyleMedia, - mkStyleMedia, unStyleMedia, - castToStyleMedia, gTypeStyleMedia, - StyleSheet(StyleSheet), StyleSheetClass, - toStyleSheet, - mkStyleSheet, unStyleSheet, - castToStyleSheet, gTypeStyleSheet, - CSSStyleSheet(CSSStyleSheet), CSSStyleSheetClass, - toCSSStyleSheet, - mkCSSStyleSheet, unCSSStyleSheet, - castToCSSStyleSheet, gTypeCSSStyleSheet, - StyleSheetList(StyleSheetList), StyleSheetListClass, - toStyleSheetList, - mkStyleSheetList, unStyleSheetList, - castToStyleSheetList, gTypeStyleSheetList, - TimeRanges(TimeRanges), TimeRangesClass, - toTimeRanges, - mkTimeRanges, unTimeRanges, - castToTimeRanges, gTypeTimeRanges, - TreeWalker(TreeWalker), TreeWalkerClass, - toTreeWalker, - mkTreeWalker, unTreeWalker, - castToTreeWalker, gTypeTreeWalker, - ValidityState(ValidityState), ValidityStateClass, - toValidityState, - mkValidityState, unValidityState, - castToValidityState, gTypeValidityState, - WebKitNamedFlow(WebKitNamedFlow), WebKitNamedFlowClass, - toWebKitNamedFlow, - mkWebKitNamedFlow, unWebKitNamedFlow, - castToWebKitNamedFlow, gTypeWebKitNamedFlow, - WebKitPoint(WebKitPoint), WebKitPointClass, - toWebKitPoint, - mkWebKitPoint, unWebKitPoint, - castToWebKitPoint, gTypeWebKitPoint, - XPathExpression(XPathExpression), XPathExpressionClass, - toXPathExpression, - mkXPathExpression, unXPathExpression, - castToXPathExpression, gTypeXPathExpression, - XPathNSResolver(XPathNSResolver), XPathNSResolverClass, - toXPathNSResolver, - mkXPathNSResolver, unXPathNSResolver, - castToXPathNSResolver, gTypeXPathNSResolver, - XPathResult(XPathResult), XPathResultClass, - toXPathResult, - mkXPathResult, unXPathResult, - castToXPathResult, gTypeXPathResult - ) where - -import Foreign.ForeignPtr (ForeignPtr, castForeignPtr) -#if __GLASGOW_HASKELL__ >= 707 -import Foreign.ForeignPtr.Unsafe (unsafeForeignPtrToPtr) -#else -import Foreign.ForeignPtr (unsafeForeignPtrToPtr) -#endif -import Foreign.C.Types (CULong(..), CUInt(..)) -import System.Glib.GType (GType, typeInstanceIsA) -{#import Graphics.UI.GtkInternals#} - -{# context lib="gtk" prefix="gtk" #} - --- The usage of foreignPtrToPtr should be safe as the evaluation will only be --- forced if the object is used afterwards --- -castTo :: (GObjectClass obj, GObjectClass obj') => GType -> String - -> (obj -> obj') -castTo gtype objTypeName obj = - case toGObject obj of - gobj@(GObject objFPtr) - | typeInstanceIsA ((unsafeForeignPtrToPtr.castForeignPtr) objFPtr) gtype - -> unsafeCastGObject gobj - | otherwise -> error $ "Cannot cast object to " ++ objTypeName - - --- ******************************************************************** WebView - -{#pointer *WebKitWebView as WebView foreign newtype #} deriving (Eq,Ord) - -mkWebView = (WebView, objectUnrefFromMainloop) -unWebView (WebView o) = o - -class ContainerClass o => WebViewClass o -toWebView :: WebViewClass o => o -> WebView -toWebView = unsafeCastGObject . toGObject - -instance WebViewClass WebView -instance ContainerClass WebView -instance WidgetClass WebView -instance GObjectClass WebView where - toGObject = GObject . castForeignPtr . unWebView - unsafeCastGObject = WebView . castForeignPtr . unGObject - -castToWebView :: GObjectClass obj => obj -> WebView -castToWebView = castTo gTypeWebView "WebView" - -gTypeWebView :: GType -gTypeWebView = - {# call fun unsafe webkit_web_view_get_type #} - --- ******************************************************************* WebFrame - -{#pointer *WebKitWebFrame as WebFrame foreign newtype #} deriving (Eq,Ord) - -mkWebFrame = (WebFrame, objectUnrefFromMainloop) -unWebFrame (WebFrame o) = o - -class GObjectClass o => WebFrameClass o -toWebFrame :: WebFrameClass o => o -> WebFrame -toWebFrame = unsafeCastGObject . toGObject - -instance WebFrameClass WebFrame -instance GObjectClass WebFrame where - toGObject = GObject . castForeignPtr . unWebFrame - unsafeCastGObject = WebFrame . castForeignPtr . unGObject - -castToWebFrame :: GObjectClass obj => obj -> WebFrame -castToWebFrame = castTo gTypeWebFrame "WebFrame" - -gTypeWebFrame :: GType -gTypeWebFrame = - {# call fun unsafe webkit_web_frame_get_type #} - --- **************************************************************** WebSettings - -{#pointer *WebKitWebSettings as WebSettings foreign newtype #} deriving (Eq,Ord) - -mkWebSettings = (WebSettings, objectUnrefFromMainloop) -unWebSettings (WebSettings o) = o - -class GObjectClass o => WebSettingsClass o -toWebSettings :: WebSettingsClass o => o -> WebSettings -toWebSettings = unsafeCastGObject . toGObject - -instance WebSettingsClass WebSettings -instance GObjectClass WebSettings where - toGObject = GObject . castForeignPtr . unWebSettings - unsafeCastGObject = WebSettings . castForeignPtr . unGObject - -castToWebSettings :: GObjectClass obj => obj -> WebSettings -castToWebSettings = castTo gTypeWebSettings "WebSettings" - -gTypeWebSettings :: GType -gTypeWebSettings = - {# call fun unsafe webkit_web_settings_get_type #} - --- ************************************************************* NetworkRequest - -{#pointer *WebKitNetworkRequest as NetworkRequest foreign newtype #} deriving (Eq,Ord) - -mkNetworkRequest = (NetworkRequest, objectUnrefFromMainloop) -unNetworkRequest (NetworkRequest o) = o - -class GObjectClass o => NetworkRequestClass o -toNetworkRequest :: NetworkRequestClass o => o -> NetworkRequest -toNetworkRequest = unsafeCastGObject . toGObject - -instance NetworkRequestClass NetworkRequest -instance GObjectClass NetworkRequest where - toGObject = GObject . castForeignPtr . unNetworkRequest - unsafeCastGObject = NetworkRequest . castForeignPtr . unGObject - -castToNetworkRequest :: GObjectClass obj => obj -> NetworkRequest -castToNetworkRequest = castTo gTypeNetworkRequest "NetworkRequest" - -gTypeNetworkRequest :: GType -gTypeNetworkRequest = - {# call fun unsafe webkit_network_request_get_type #} - --- ************************************************************ NetworkResponse - -{#pointer *WebKitNetworkResponse as NetworkResponse foreign newtype #} deriving (Eq,Ord) - -mkNetworkResponse = (NetworkResponse, objectUnrefFromMainloop) -unNetworkResponse (NetworkResponse o) = o - -class GObjectClass o => NetworkResponseClass o -toNetworkResponse :: NetworkResponseClass o => o -> NetworkResponse -toNetworkResponse = unsafeCastGObject . toGObject - -instance NetworkResponseClass NetworkResponse -instance GObjectClass NetworkResponse where - toGObject = GObject . castForeignPtr . unNetworkResponse - unsafeCastGObject = NetworkResponse . castForeignPtr . unGObject - -castToNetworkResponse :: GObjectClass obj => obj -> NetworkResponse -castToNetworkResponse = castTo gTypeNetworkResponse "NetworkResponse" - -gTypeNetworkResponse :: GType -gTypeNetworkResponse = - {# call fun unsafe webkit_network_response_get_type #} - --- ******************************************************************* Download - -{#pointer *WebKitDownload as Download foreign newtype #} deriving (Eq,Ord) - -mkDownload = (Download, objectUnrefFromMainloop) -unDownload (Download o) = o - -class GObjectClass o => DownloadClass o -toDownload :: DownloadClass o => o -> Download -toDownload = unsafeCastGObject . toGObject - -instance DownloadClass Download -instance GObjectClass Download where - toGObject = GObject . castForeignPtr . unDownload - unsafeCastGObject = Download . castForeignPtr . unGObject - -castToDownload :: GObjectClass obj => obj -> Download -castToDownload = castTo gTypeDownload "Download" - -gTypeDownload :: GType -gTypeDownload = - {# call fun unsafe webkit_download_get_type #} - --- ********************************************************* WebBackForwardList - -{#pointer *WebKitWebBackForwardList as WebBackForwardList foreign newtype #} deriving (Eq,Ord) - -mkWebBackForwardList = (WebBackForwardList, objectUnrefFromMainloop) -unWebBackForwardList (WebBackForwardList o) = o - -class GObjectClass o => WebBackForwardListClass o -toWebBackForwardList :: WebBackForwardListClass o => o -> WebBackForwardList -toWebBackForwardList = unsafeCastGObject . toGObject - -instance WebBackForwardListClass WebBackForwardList -instance GObjectClass WebBackForwardList where - toGObject = GObject . castForeignPtr . unWebBackForwardList - unsafeCastGObject = WebBackForwardList . castForeignPtr . unGObject - -castToWebBackForwardList :: GObjectClass obj => obj -> WebBackForwardList -castToWebBackForwardList = castTo gTypeWebBackForwardList "WebBackForwardList" - -gTypeWebBackForwardList :: GType -gTypeWebBackForwardList = - {# call fun unsafe webkit_web_back_forward_list_get_type #} - --- ************************************************************* WebHistoryItem - -{#pointer *WebKitWebHistoryItem as WebHistoryItem foreign newtype #} deriving (Eq,Ord) - -mkWebHistoryItem = (WebHistoryItem, objectUnrefFromMainloop) -unWebHistoryItem (WebHistoryItem o) = o - -class GObjectClass o => WebHistoryItemClass o -toWebHistoryItem :: WebHistoryItemClass o => o -> WebHistoryItem -toWebHistoryItem = unsafeCastGObject . toGObject - -instance WebHistoryItemClass WebHistoryItem -instance GObjectClass WebHistoryItem where - toGObject = GObject . castForeignPtr . unWebHistoryItem - unsafeCastGObject = WebHistoryItem . castForeignPtr . unGObject - -castToWebHistoryItem :: GObjectClass obj => obj -> WebHistoryItem -castToWebHistoryItem = castTo gTypeWebHistoryItem "WebHistoryItem" - -gTypeWebHistoryItem :: GType -gTypeWebHistoryItem = - {# call fun unsafe webkit_web_history_item_get_type #} - --- *************************************************************** WebInspector - -{#pointer *WebKitWebInspector as WebInspector foreign newtype #} deriving (Eq,Ord) - -mkWebInspector = (WebInspector, objectUnrefFromMainloop) -unWebInspector (WebInspector o) = o - -class GObjectClass o => WebInspectorClass o -toWebInspector :: WebInspectorClass o => o -> WebInspector -toWebInspector = unsafeCastGObject . toGObject - -instance WebInspectorClass WebInspector -instance GObjectClass WebInspector where - toGObject = GObject . castForeignPtr . unWebInspector - unsafeCastGObject = WebInspector . castForeignPtr . unGObject - -castToWebInspector :: GObjectClass obj => obj -> WebInspector -castToWebInspector = castTo gTypeWebInspector "WebInspector" - -gTypeWebInspector :: GType -gTypeWebInspector = - {# call fun unsafe webkit_web_inspector_get_type #} - --- ************************************************************** HitTestResult - -{#pointer *WebKitHitTestResult as HitTestResult foreign newtype #} deriving (Eq,Ord) - -mkHitTestResult = (HitTestResult, objectUnrefFromMainloop) -unHitTestResult (HitTestResult o) = o - -class GObjectClass o => HitTestResultClass o -toHitTestResult :: HitTestResultClass o => o -> HitTestResult -toHitTestResult = unsafeCastGObject . toGObject - -instance HitTestResultClass HitTestResult -instance GObjectClass HitTestResult where - toGObject = GObject . castForeignPtr . unHitTestResult - unsafeCastGObject = HitTestResult . castForeignPtr . unGObject - -castToHitTestResult :: GObjectClass obj => obj -> HitTestResult -castToHitTestResult = castTo gTypeHitTestResult "HitTestResult" - -gTypeHitTestResult :: GType -gTypeHitTestResult = - {# call fun unsafe webkit_hit_test_result_get_type #} - --- ************************************************************* SecurityOrigin - -{#pointer *WebKitSecurityOrigin as SecurityOrigin foreign newtype #} deriving (Eq,Ord) - -mkSecurityOrigin = (SecurityOrigin, objectUnrefFromMainloop) -unSecurityOrigin (SecurityOrigin o) = o - -class GObjectClass o => SecurityOriginClass o -toSecurityOrigin :: SecurityOriginClass o => o -> SecurityOrigin -toSecurityOrigin = unsafeCastGObject . toGObject - -instance SecurityOriginClass SecurityOrigin -instance GObjectClass SecurityOrigin where - toGObject = GObject . castForeignPtr . unSecurityOrigin - unsafeCastGObject = SecurityOrigin . castForeignPtr . unGObject - -castToSecurityOrigin :: GObjectClass obj => obj -> SecurityOrigin -castToSecurityOrigin = castTo gTypeSecurityOrigin "SecurityOrigin" - -gTypeSecurityOrigin :: GType -gTypeSecurityOrigin = - {# call fun unsafe webkit_security_origin_get_type #} - --- ************************************************************* SoupAuthDialog - -{#pointer *WebKitSoupAuthDialog as SoupAuthDialog foreign newtype #} deriving (Eq,Ord) - -mkSoupAuthDialog = (SoupAuthDialog, objectUnrefFromMainloop) -unSoupAuthDialog (SoupAuthDialog o) = o - -class GObjectClass o => SoupAuthDialogClass o -toSoupAuthDialog :: SoupAuthDialogClass o => o -> SoupAuthDialog -toSoupAuthDialog = unsafeCastGObject . toGObject - -instance SoupAuthDialogClass SoupAuthDialog -instance GObjectClass SoupAuthDialog where - toGObject = GObject . castForeignPtr . unSoupAuthDialog - unsafeCastGObject = SoupAuthDialog . castForeignPtr . unGObject - -castToSoupAuthDialog :: GObjectClass obj => obj -> SoupAuthDialog -castToSoupAuthDialog = castTo gTypeSoupAuthDialog "SoupAuthDialog" - -gTypeSoupAuthDialog :: GType -gTypeSoupAuthDialog = - {# call fun unsafe webkit_soup_auth_dialog_get_type #} - --- **************************************************************** WebDatabase - -{#pointer *WebKitWebDatabase as WebDatabase foreign newtype #} deriving (Eq,Ord) - -mkWebDatabase = (WebDatabase, objectUnrefFromMainloop) -unWebDatabase (WebDatabase o) = o - -class GObjectClass o => WebDatabaseClass o -toWebDatabase :: WebDatabaseClass o => o -> WebDatabase -toWebDatabase = unsafeCastGObject . toGObject - -instance WebDatabaseClass WebDatabase -instance GObjectClass WebDatabase where - toGObject = GObject . castForeignPtr . unWebDatabase - unsafeCastGObject = WebDatabase . castForeignPtr . unGObject - -castToWebDatabase :: GObjectClass obj => obj -> WebDatabase -castToWebDatabase = castTo gTypeWebDatabase "WebDatabase" - -gTypeWebDatabase :: GType -gTypeWebDatabase = - {# call fun unsafe webkit_web_database_get_type #} - --- ************************************************************** WebDataSource - -{#pointer *WebKitWebDataSource as WebDataSource foreign newtype #} deriving (Eq,Ord) - -mkWebDataSource = (WebDataSource, objectUnrefFromMainloop) -unWebDataSource (WebDataSource o) = o - -class GObjectClass o => WebDataSourceClass o -toWebDataSource :: WebDataSourceClass o => o -> WebDataSource -toWebDataSource = unsafeCastGObject . toGObject - -instance WebDataSourceClass WebDataSource -instance GObjectClass WebDataSource where - toGObject = GObject . castForeignPtr . unWebDataSource - unsafeCastGObject = WebDataSource . castForeignPtr . unGObject - -castToWebDataSource :: GObjectClass obj => obj -> WebDataSource -castToWebDataSource = castTo gTypeWebDataSource "WebDataSource" - -gTypeWebDataSource :: GType -gTypeWebDataSource = - {# call fun unsafe webkit_web_data_source_get_type #} - --- ******************************************************** WebNavigationAction - -{#pointer *WebKitWebNavigationAction as WebNavigationAction foreign newtype #} deriving (Eq,Ord) - -mkWebNavigationAction = (WebNavigationAction, objectUnrefFromMainloop) -unWebNavigationAction (WebNavigationAction o) = o - -class GObjectClass o => WebNavigationActionClass o -toWebNavigationAction :: WebNavigationActionClass o => o -> WebNavigationAction -toWebNavigationAction = unsafeCastGObject . toGObject - -instance WebNavigationActionClass WebNavigationAction -instance GObjectClass WebNavigationAction where - toGObject = GObject . castForeignPtr . unWebNavigationAction - unsafeCastGObject = WebNavigationAction . castForeignPtr . unGObject - -castToWebNavigationAction :: GObjectClass obj => obj -> WebNavigationAction -castToWebNavigationAction = castTo gTypeWebNavigationAction "WebNavigationAction" - -gTypeWebNavigationAction :: GType -gTypeWebNavigationAction = - {# call fun unsafe webkit_web_navigation_action_get_type #} - --- ********************************************************** WebPolicyDecision - -{#pointer *WebKitWebPolicyDecision as WebPolicyDecision foreign newtype #} deriving (Eq,Ord) - -mkWebPolicyDecision = (WebPolicyDecision, objectUnrefFromMainloop) -unWebPolicyDecision (WebPolicyDecision o) = o - -class GObjectClass o => WebPolicyDecisionClass o -toWebPolicyDecision :: WebPolicyDecisionClass o => o -> WebPolicyDecision -toWebPolicyDecision = unsafeCastGObject . toGObject - -instance WebPolicyDecisionClass WebPolicyDecision -instance GObjectClass WebPolicyDecision where - toGObject = GObject . castForeignPtr . unWebPolicyDecision - unsafeCastGObject = WebPolicyDecision . castForeignPtr . unGObject - -castToWebPolicyDecision :: GObjectClass obj => obj -> WebPolicyDecision -castToWebPolicyDecision = castTo gTypeWebPolicyDecision "WebPolicyDecision" - -gTypeWebPolicyDecision :: GType -gTypeWebPolicyDecision = - {# call fun unsafe webkit_web_policy_decision_get_type #} - --- **************************************************************** WebResource - -{#pointer *WebKitWebResource as WebResource foreign newtype #} deriving (Eq,Ord) - -mkWebResource = (WebResource, objectUnrefFromMainloop) -unWebResource (WebResource o) = o - -class GObjectClass o => WebResourceClass o -toWebResource :: WebResourceClass o => o -> WebResource -toWebResource = unsafeCastGObject . toGObject - -instance WebResourceClass WebResource -instance GObjectClass WebResource where - toGObject = GObject . castForeignPtr . unWebResource - unsafeCastGObject = WebResource . castForeignPtr . unGObject - -castToWebResource :: GObjectClass obj => obj -> WebResource -castToWebResource = castTo gTypeWebResource "WebResource" - -gTypeWebResource :: GType -gTypeWebResource = - {# call fun unsafe webkit_web_resource_get_type #} - --- ********************************************************** WebWindowFeatures - -{#pointer *WebKitWebWindowFeatures as WebWindowFeatures foreign newtype #} deriving (Eq,Ord) - -mkWebWindowFeatures = (WebWindowFeatures, objectUnrefFromMainloop) -unWebWindowFeatures (WebWindowFeatures o) = o - -class GObjectClass o => WebWindowFeaturesClass o -toWebWindowFeatures :: WebWindowFeaturesClass o => o -> WebWindowFeatures -toWebWindowFeatures = unsafeCastGObject . toGObject - -instance WebWindowFeaturesClass WebWindowFeatures -instance GObjectClass WebWindowFeatures where - toGObject = GObject . castForeignPtr . unWebWindowFeatures - unsafeCastGObject = WebWindowFeatures . castForeignPtr . unGObject - -castToWebWindowFeatures :: GObjectClass obj => obj -> WebWindowFeatures -castToWebWindowFeatures = castTo gTypeWebWindowFeatures "WebWindowFeatures" - -gTypeWebWindowFeatures :: GType -gTypeWebWindowFeatures = - {# call fun unsafe webkit_web_window_features_get_type #} - --- ************************************************** GeolocationPolicyDecision - -{#pointer *WebKitGeolocationPolicyDecision as GeolocationPolicyDecision foreign newtype #} deriving (Eq,Ord) - -mkGeolocationPolicyDecision = (GeolocationPolicyDecision, objectUnrefFromMainloop) -unGeolocationPolicyDecision (GeolocationPolicyDecision o) = o - -class GObjectClass o => GeolocationPolicyDecisionClass o -toGeolocationPolicyDecision :: GeolocationPolicyDecisionClass o => o -> GeolocationPolicyDecision -toGeolocationPolicyDecision = unsafeCastGObject . toGObject - -instance GeolocationPolicyDecisionClass GeolocationPolicyDecision -instance GObjectClass GeolocationPolicyDecision where - toGObject = GObject . castForeignPtr . unGeolocationPolicyDecision - unsafeCastGObject = GeolocationPolicyDecision . castForeignPtr . unGObject - -castToGeolocationPolicyDecision :: GObjectClass obj => obj -> GeolocationPolicyDecision -castToGeolocationPolicyDecision = castTo gTypeGeolocationPolicyDecision "GeolocationPolicyDecision" - -gTypeGeolocationPolicyDecision :: GType -gTypeGeolocationPolicyDecision = - {# call fun unsafe webkit_geolocation_policy_decision_get_type #} - --- ******************************************************************** BarProp - -{#pointer *WebKitDOMBarProp as BarProp foreign newtype #} deriving (Eq,Ord) - -mkBarProp = (BarProp, objectUnrefFromMainloop) -unBarProp (BarProp o) = o - -class GObjectClass o => BarPropClass o -toBarProp :: BarPropClass o => o -> BarProp -toBarProp = unsafeCastGObject . toGObject - -instance BarPropClass BarProp -instance GObjectClass BarProp where - toGObject = GObject . castForeignPtr . unBarProp - unsafeCastGObject = BarProp . castForeignPtr . unGObject - -castToBarProp :: GObjectClass obj => obj -> BarProp -castToBarProp = castTo gTypeBarProp "BarProp" - -gTypeBarProp :: GType -gTypeBarProp = - {# call fun unsafe webkit_dom_bar_prop_get_type #} - --- *********************************************************************** Blob - -{#pointer *WebKitDOMBlob as Blob foreign newtype #} deriving (Eq,Ord) - -mkBlob = (Blob, objectUnrefFromMainloop) -unBlob (Blob o) = o - -class GObjectClass o => BlobClass o -toBlob :: BlobClass o => o -> Blob -toBlob = unsafeCastGObject . toGObject - -instance BlobClass Blob -instance GObjectClass Blob where - toGObject = GObject . castForeignPtr . unBlob - unsafeCastGObject = Blob . castForeignPtr . unGObject - -castToBlob :: GObjectClass obj => obj -> Blob -castToBlob = castTo gTypeBlob "Blob" - -gTypeBlob :: GType -gTypeBlob = - {# call fun unsafe webkit_dom_blob_get_type #} - --- *********************************************************************** File - -{#pointer *WebKitDOMFile as File foreign newtype #} deriving (Eq,Ord) - -mkFile = (File, objectUnrefFromMainloop) -unFile (File o) = o - -class BlobClass o => FileClass o -toFile :: FileClass o => o -> File -toFile = unsafeCastGObject . toGObject - -instance FileClass File -instance BlobClass File -instance GObjectClass File where - toGObject = GObject . castForeignPtr . unFile - unsafeCastGObject = File . castForeignPtr . unGObject - -castToFile :: GObjectClass obj => obj -> File -castToFile = castTo gTypeFile "File" - -gTypeFile :: GType -gTypeFile = - {# call fun unsafe webkit_dom_file_get_type #} - --- ******************************************************************** CSSRule - -{#pointer *WebKitDOMCSSRule as CSSRule foreign newtype #} deriving (Eq,Ord) - -mkCSSRule = (CSSRule, objectUnrefFromMainloop) -unCSSRule (CSSRule o) = o - -class GObjectClass o => CSSRuleClass o -toCSSRule :: CSSRuleClass o => o -> CSSRule -toCSSRule = unsafeCastGObject . toGObject - -instance CSSRuleClass CSSRule -instance GObjectClass CSSRule where - toGObject = GObject . castForeignPtr . unCSSRule - unsafeCastGObject = CSSRule . castForeignPtr . unGObject - -castToCSSRule :: GObjectClass obj => obj -> CSSRule -castToCSSRule = castTo gTypeCSSRule "CSSRule" - -gTypeCSSRule :: GType -gTypeCSSRule = - {# call fun unsafe webkit_dom_css_rule_get_type #} - --- **************************************************************** CSSRuleList - -{#pointer *WebKitDOMCSSRuleList as CSSRuleList foreign newtype #} deriving (Eq,Ord) - -mkCSSRuleList = (CSSRuleList, objectUnrefFromMainloop) -unCSSRuleList (CSSRuleList o) = o - -class GObjectClass o => CSSRuleListClass o -toCSSRuleList :: CSSRuleListClass o => o -> CSSRuleList -toCSSRuleList = unsafeCastGObject . toGObject - -instance CSSRuleListClass CSSRuleList -instance GObjectClass CSSRuleList where - toGObject = GObject . castForeignPtr . unCSSRuleList - unsafeCastGObject = CSSRuleList . castForeignPtr . unGObject - -castToCSSRuleList :: GObjectClass obj => obj -> CSSRuleList -castToCSSRuleList = castTo gTypeCSSRuleList "CSSRuleList" - -gTypeCSSRuleList :: GType -gTypeCSSRuleList = - {# call fun unsafe webkit_dom_css_rule_list_get_type #} - --- ******************************************************** CSSStyleDeclaration - -{#pointer *WebKitDOMCSSStyleDeclaration as CSSStyleDeclaration foreign newtype #} deriving (Eq,Ord) - -mkCSSStyleDeclaration = (CSSStyleDeclaration, objectUnrefFromMainloop) -unCSSStyleDeclaration (CSSStyleDeclaration o) = o - -class GObjectClass o => CSSStyleDeclarationClass o -toCSSStyleDeclaration :: CSSStyleDeclarationClass o => o -> CSSStyleDeclaration -toCSSStyleDeclaration = unsafeCastGObject . toGObject - -instance CSSStyleDeclarationClass CSSStyleDeclaration -instance GObjectClass CSSStyleDeclaration where - toGObject = GObject . castForeignPtr . unCSSStyleDeclaration - unsafeCastGObject = CSSStyleDeclaration . castForeignPtr . unGObject - -castToCSSStyleDeclaration :: GObjectClass obj => obj -> CSSStyleDeclaration -castToCSSStyleDeclaration = castTo gTypeCSSStyleDeclaration "CSSStyleDeclaration" - -gTypeCSSStyleDeclaration :: GType -gTypeCSSStyleDeclaration = - {# call fun unsafe webkit_dom_css_style_declaration_get_type #} - --- ******************************************************************* CSSValue - -{#pointer *WebKitDOMCSSValue as CSSValue foreign newtype #} deriving (Eq,Ord) - -mkCSSValue = (CSSValue, objectUnrefFromMainloop) -unCSSValue (CSSValue o) = o - -class GObjectClass o => CSSValueClass o -toCSSValue :: CSSValueClass o => o -> CSSValue -toCSSValue = unsafeCastGObject . toGObject - -instance CSSValueClass CSSValue -instance GObjectClass CSSValue where - toGObject = GObject . castForeignPtr . unCSSValue - unsafeCastGObject = CSSValue . castForeignPtr . unGObject - -castToCSSValue :: GObjectClass obj => obj -> CSSValue -castToCSSValue = castTo gTypeCSSValue "CSSValue" - -gTypeCSSValue :: GType -gTypeCSSValue = - {# call fun unsafe webkit_dom_css_value_get_type #} - --- ******************************************************************** Console - -{#pointer *WebKitDOMConsole as Console foreign newtype #} deriving (Eq,Ord) - -mkConsole = (Console, objectUnrefFromMainloop) -unConsole (Console o) = o - -class GObjectClass o => ConsoleClass o -toConsole :: ConsoleClass o => o -> Console -toConsole = unsafeCastGObject . toGObject - -instance ConsoleClass Console -instance GObjectClass Console where - toGObject = GObject . castForeignPtr . unConsole - unsafeCastGObject = Console . castForeignPtr . unGObject - -castToConsole :: GObjectClass obj => obj -> Console -castToConsole = castTo gTypeConsole "Console" - -gTypeConsole :: GType -gTypeConsole = - {# call fun unsafe webkit_dom_console_get_type #} - --- ******************************************************** DOMApplicationCache - -{#pointer *WebKitDOMDOMApplicationCache as DOMApplicationCache foreign newtype #} deriving (Eq,Ord) - -mkDOMApplicationCache = (DOMApplicationCache, objectUnrefFromMainloop) -unDOMApplicationCache (DOMApplicationCache o) = o - -class GObjectClass o => DOMApplicationCacheClass o -toDOMApplicationCache :: DOMApplicationCacheClass o => o -> DOMApplicationCache -toDOMApplicationCache = unsafeCastGObject . toGObject - -instance DOMApplicationCacheClass DOMApplicationCache -instance GObjectClass DOMApplicationCache where - toGObject = GObject . castForeignPtr . unDOMApplicationCache - unsafeCastGObject = DOMApplicationCache . castForeignPtr . unGObject - -castToDOMApplicationCache :: GObjectClass obj => obj -> DOMApplicationCache -castToDOMApplicationCache = castTo gTypeDOMApplicationCache "DOMApplicationCache" - -gTypeDOMApplicationCache :: GType -gTypeDOMApplicationCache = - {# call fun unsafe webkit_dom_dom_application_cache_get_type #} - --- ********************************************************** DOMImplementation - -{#pointer *WebKitDOMDOMImplementation as DOMImplementation foreign newtype #} deriving (Eq,Ord) - -mkDOMImplementation = (DOMImplementation, objectUnrefFromMainloop) -unDOMImplementation (DOMImplementation o) = o - -class GObjectClass o => DOMImplementationClass o -toDOMImplementation :: DOMImplementationClass o => o -> DOMImplementation -toDOMImplementation = unsafeCastGObject . toGObject - -instance DOMImplementationClass DOMImplementation -instance GObjectClass DOMImplementation where - toGObject = GObject . castForeignPtr . unDOMImplementation - unsafeCastGObject = DOMImplementation . castForeignPtr . unGObject - -castToDOMImplementation :: GObjectClass obj => obj -> DOMImplementation -castToDOMImplementation = castTo gTypeDOMImplementation "DOMImplementation" - -gTypeDOMImplementation :: GType -gTypeDOMImplementation = - {# call fun unsafe webkit_dom_dom_implementation_get_type #} - --- **************************************************************** DOMMimeType - -{#pointer *WebKitDOMDOMMimeType as DOMMimeType foreign newtype #} deriving (Eq,Ord) - -mkDOMMimeType = (DOMMimeType, objectUnrefFromMainloop) -unDOMMimeType (DOMMimeType o) = o - -class GObjectClass o => DOMMimeTypeClass o -toDOMMimeType :: DOMMimeTypeClass o => o -> DOMMimeType -toDOMMimeType = unsafeCastGObject . toGObject - -instance DOMMimeTypeClass DOMMimeType -instance GObjectClass DOMMimeType where - toGObject = GObject . castForeignPtr . unDOMMimeType - unsafeCastGObject = DOMMimeType . castForeignPtr . unGObject - -castToDOMMimeType :: GObjectClass obj => obj -> DOMMimeType -castToDOMMimeType = castTo gTypeDOMMimeType "DOMMimeType" - -gTypeDOMMimeType :: GType -gTypeDOMMimeType = - {# call fun unsafe webkit_dom_dom_mime_type_get_type #} - --- *********************************************************** DOMMimeTypeArray - -{#pointer *WebKitDOMDOMMimeTypeArray as DOMMimeTypeArray foreign newtype #} deriving (Eq,Ord) - -mkDOMMimeTypeArray = (DOMMimeTypeArray, objectUnrefFromMainloop) -unDOMMimeTypeArray (DOMMimeTypeArray o) = o - -class GObjectClass o => DOMMimeTypeArrayClass o -toDOMMimeTypeArray :: DOMMimeTypeArrayClass o => o -> DOMMimeTypeArray -toDOMMimeTypeArray = unsafeCastGObject . toGObject - -instance DOMMimeTypeArrayClass DOMMimeTypeArray -instance GObjectClass DOMMimeTypeArray where - toGObject = GObject . castForeignPtr . unDOMMimeTypeArray - unsafeCastGObject = DOMMimeTypeArray . castForeignPtr . unGObject - -castToDOMMimeTypeArray :: GObjectClass obj => obj -> DOMMimeTypeArray -castToDOMMimeTypeArray = castTo gTypeDOMMimeTypeArray "DOMMimeTypeArray" - -gTypeDOMMimeTypeArray :: GType -gTypeDOMMimeTypeArray = - {# call fun unsafe webkit_dom_dom_mime_type_array_get_type #} - --- ***************************************************** DOMNamedFlowCollection - -{#pointer *WebKitDOMDOMNamedFlowCollection as DOMNamedFlowCollection foreign newtype #} deriving (Eq,Ord) - -mkDOMNamedFlowCollection = (DOMNamedFlowCollection, objectUnrefFromMainloop) -unDOMNamedFlowCollection (DOMNamedFlowCollection o) = o - -class GObjectClass o => DOMNamedFlowCollectionClass o -toDOMNamedFlowCollection :: DOMNamedFlowCollectionClass o => o -> DOMNamedFlowCollection -toDOMNamedFlowCollection = unsafeCastGObject . toGObject - -instance DOMNamedFlowCollectionClass DOMNamedFlowCollection -instance GObjectClass DOMNamedFlowCollection where - toGObject = GObject . castForeignPtr . unDOMNamedFlowCollection - unsafeCastGObject = DOMNamedFlowCollection . castForeignPtr . unGObject - -castToDOMNamedFlowCollection :: GObjectClass obj => obj -> DOMNamedFlowCollection -castToDOMNamedFlowCollection = castTo gTypeDOMNamedFlowCollection "DOMNamedFlowCollection" - -gTypeDOMNamedFlowCollection :: GType -gTypeDOMNamedFlowCollection = - {# call fun unsafe webkit_dom_dom_named_flow_collection_get_type #} - --- ****************************************************************** DOMPlugin - -{#pointer *WebKitDOMDOMPlugin as DOMPlugin foreign newtype #} deriving (Eq,Ord) - -mkDOMPlugin = (DOMPlugin, objectUnrefFromMainloop) -unDOMPlugin (DOMPlugin o) = o - -class GObjectClass o => DOMPluginClass o -toDOMPlugin :: DOMPluginClass o => o -> DOMPlugin -toDOMPlugin = unsafeCastGObject . toGObject - -instance DOMPluginClass DOMPlugin -instance GObjectClass DOMPlugin where - toGObject = GObject . castForeignPtr . unDOMPlugin - unsafeCastGObject = DOMPlugin . castForeignPtr . unGObject - -castToDOMPlugin :: GObjectClass obj => obj -> DOMPlugin -castToDOMPlugin = castTo gTypeDOMPlugin "DOMPlugin" - -gTypeDOMPlugin :: GType -gTypeDOMPlugin = - {# call fun unsafe webkit_dom_dom_plugin_get_type #} - --- ************************************************************* DOMPluginArray - -{#pointer *WebKitDOMDOMPluginArray as DOMPluginArray foreign newtype #} deriving (Eq,Ord) - -mkDOMPluginArray = (DOMPluginArray, objectUnrefFromMainloop) -unDOMPluginArray (DOMPluginArray o) = o - -class GObjectClass o => DOMPluginArrayClass o -toDOMPluginArray :: DOMPluginArrayClass o => o -> DOMPluginArray -toDOMPluginArray = unsafeCastGObject . toGObject - -instance DOMPluginArrayClass DOMPluginArray -instance GObjectClass DOMPluginArray where - toGObject = GObject . castForeignPtr . unDOMPluginArray - unsafeCastGObject = DOMPluginArray . castForeignPtr . unGObject - -castToDOMPluginArray :: GObjectClass obj => obj -> DOMPluginArray -castToDOMPluginArray = castTo gTypeDOMPluginArray "DOMPluginArray" - -gTypeDOMPluginArray :: GType -gTypeDOMPluginArray = - {# call fun unsafe webkit_dom_dom_plugin_array_get_type #} - --- ********************************************************** DOMSecurityPolicy - -{#pointer *WebKitDOMDOMSecurityPolicy as DOMSecurityPolicy foreign newtype #} deriving (Eq,Ord) - -mkDOMSecurityPolicy = (DOMSecurityPolicy, objectUnrefFromMainloop) -unDOMSecurityPolicy (DOMSecurityPolicy o) = o - -class GObjectClass o => DOMSecurityPolicyClass o -toDOMSecurityPolicy :: DOMSecurityPolicyClass o => o -> DOMSecurityPolicy -toDOMSecurityPolicy = unsafeCastGObject . toGObject - -instance DOMSecurityPolicyClass DOMSecurityPolicy -instance GObjectClass DOMSecurityPolicy where - toGObject = GObject . castForeignPtr . unDOMSecurityPolicy - unsafeCastGObject = DOMSecurityPolicy . castForeignPtr . unGObject - -castToDOMSecurityPolicy :: GObjectClass obj => obj -> DOMSecurityPolicy -castToDOMSecurityPolicy = castTo gTypeDOMSecurityPolicy "DOMSecurityPolicy" - -gTypeDOMSecurityPolicy :: GType -gTypeDOMSecurityPolicy = - {# call fun unsafe webkit_dom_dom_security_policy_get_type #} - --- *************************************************************** DOMSelection - -{#pointer *WebKitDOMDOMSelection as DOMSelection foreign newtype #} deriving (Eq,Ord) - -mkDOMSelection = (DOMSelection, objectUnrefFromMainloop) -unDOMSelection (DOMSelection o) = o - -class GObjectClass o => DOMSelectionClass o -toDOMSelection :: DOMSelectionClass o => o -> DOMSelection -toDOMSelection = unsafeCastGObject . toGObject - -instance DOMSelectionClass DOMSelection -instance GObjectClass DOMSelection where - toGObject = GObject . castForeignPtr . unDOMSelection - unsafeCastGObject = DOMSelection . castForeignPtr . unGObject - -castToDOMSelection :: GObjectClass obj => obj -> DOMSelection -castToDOMSelection = castTo gTypeDOMSelection "DOMSelection" - -gTypeDOMSelection :: GType -gTypeDOMSelection = - {# call fun unsafe webkit_dom_dom_selection_get_type #} - --- ************************************************************** DOMStringList - -{#pointer *WebKitDOMDOMStringList as DOMStringList foreign newtype #} deriving (Eq,Ord) - -mkDOMStringList = (DOMStringList, objectUnrefFromMainloop) -unDOMStringList (DOMStringList o) = o - -class GObjectClass o => DOMStringListClass o -toDOMStringList :: DOMStringListClass o => o -> DOMStringList -toDOMStringList = unsafeCastGObject . toGObject - -instance DOMStringListClass DOMStringList -instance GObjectClass DOMStringList where - toGObject = GObject . castForeignPtr . unDOMStringList - unsafeCastGObject = DOMStringList . castForeignPtr . unGObject - -castToDOMStringList :: GObjectClass obj => obj -> DOMStringList -castToDOMStringList = castTo gTypeDOMStringList "DOMStringList" - -gTypeDOMStringList :: GType -gTypeDOMStringList = - {# call fun unsafe webkit_dom_dom_string_list_get_type #} - --- *************************************************************** DOMTokenList - -{#pointer *WebKitDOMDOMTokenList as DOMTokenList foreign newtype #} deriving (Eq,Ord) - -mkDOMTokenList = (DOMTokenList, objectUnrefFromMainloop) -unDOMTokenList (DOMTokenList o) = o - -class GObjectClass o => DOMTokenListClass o -toDOMTokenList :: DOMTokenListClass o => o -> DOMTokenList -toDOMTokenList = unsafeCastGObject . toGObject - -instance DOMTokenListClass DOMTokenList -instance GObjectClass DOMTokenList where - toGObject = GObject . castForeignPtr . unDOMTokenList - unsafeCastGObject = DOMTokenList . castForeignPtr . unGObject - -castToDOMTokenList :: GObjectClass obj => obj -> DOMTokenList -castToDOMTokenList = castTo gTypeDOMTokenList "DOMTokenList" - -gTypeDOMTokenList :: GType -gTypeDOMTokenList = - {# call fun unsafe webkit_dom_dom_token_list_get_type #} - --- ******************************************************* DOMSettableTokenList - -{#pointer *WebKitDOMDOMSettableTokenList as DOMSettableTokenList foreign newtype #} deriving (Eq,Ord) - -mkDOMSettableTokenList = (DOMSettableTokenList, objectUnrefFromMainloop) -unDOMSettableTokenList (DOMSettableTokenList o) = o - -class DOMTokenListClass o => DOMSettableTokenListClass o -toDOMSettableTokenList :: DOMSettableTokenListClass o => o -> DOMSettableTokenList -toDOMSettableTokenList = unsafeCastGObject . toGObject - -instance DOMSettableTokenListClass DOMSettableTokenList -instance DOMTokenListClass DOMSettableTokenList -instance GObjectClass DOMSettableTokenList where - toGObject = GObject . castForeignPtr . unDOMSettableTokenList - unsafeCastGObject = DOMSettableTokenList . castForeignPtr . unGObject - -castToDOMSettableTokenList :: GObjectClass obj => obj -> DOMSettableTokenList -castToDOMSettableTokenList = castTo gTypeDOMSettableTokenList "DOMSettableTokenList" - -gTypeDOMSettableTokenList :: GType -gTypeDOMSettableTokenList = - {# call fun unsafe webkit_dom_dom_settable_token_list_get_type #} - --- ****************************************************************** DOMWindow - -{#pointer *WebKitDOMDOMWindow as DOMWindow foreign newtype #} deriving (Eq,Ord) - -mkDOMWindow = (DOMWindow, objectUnrefFromMainloop) -unDOMWindow (DOMWindow o) = o - -class GObjectClass o => DOMWindowClass o -toDOMWindow :: DOMWindowClass o => o -> DOMWindow -toDOMWindow = unsafeCastGObject . toGObject - -instance DOMWindowClass DOMWindow -instance GObjectClass DOMWindow where - toGObject = GObject . castForeignPtr . unDOMWindow - unsafeCastGObject = DOMWindow . castForeignPtr . unGObject - -castToDOMWindow :: GObjectClass obj => obj -> DOMWindow -castToDOMWindow = castTo gTypeDOMWindow "DOMWindow" - -gTypeDOMWindow :: GType -gTypeDOMWindow = - {# call fun unsafe webkit_dom_dom_window_get_type #} - --- *************************************************************** DOMWindowCSS - -{#pointer *WebKitDOMDOMWindowCSS as DOMWindowCSS foreign newtype #} deriving (Eq,Ord) - -mkDOMWindowCSS = (DOMWindowCSS, objectUnrefFromMainloop) -unDOMWindowCSS (DOMWindowCSS o) = o - -class GObjectClass o => DOMWindowCSSClass o -toDOMWindowCSS :: DOMWindowCSSClass o => o -> DOMWindowCSS -toDOMWindowCSS = unsafeCastGObject . toGObject - -instance DOMWindowCSSClass DOMWindowCSS -instance GObjectClass DOMWindowCSS where - toGObject = GObject . castForeignPtr . unDOMWindowCSS - unsafeCastGObject = DOMWindowCSS . castForeignPtr . unGObject - -castToDOMWindowCSS :: GObjectClass obj => obj -> DOMWindowCSS -castToDOMWindowCSS = castTo gTypeDOMWindowCSS "DOMWindowCSS" - -gTypeDOMWindowCSS :: GType -gTypeDOMWindowCSS = - {# call fun unsafe webkit_dom_dom_window_css_get_type #} - --- ********************************************************************** Event - -{#pointer *WebKitDOMEvent as Event foreign newtype #} deriving (Eq,Ord) - -mkEvent = (Event, objectUnrefFromMainloop) -unEvent (Event o) = o - -class GObjectClass o => EventClass o -toEvent :: EventClass o => o -> Event -toEvent = unsafeCastGObject . toGObject - -instance EventClass Event -instance GObjectClass Event where - toGObject = GObject . castForeignPtr . unEvent - unsafeCastGObject = Event . castForeignPtr . unGObject - -castToEvent :: GObjectClass obj => obj -> Event -castToEvent = castTo gTypeEvent "Event" - -gTypeEvent :: GType -gTypeEvent = - {# call fun unsafe webkit_dom_event_get_type #} - --- ******************************************************************** UIEvent - -{#pointer *WebKitDOMUIEvent as UIEvent foreign newtype #} deriving (Eq,Ord) - -mkUIEvent = (UIEvent, objectUnrefFromMainloop) -unUIEvent (UIEvent o) = o - -class EventClass o => UIEventClass o -toUIEvent :: UIEventClass o => o -> UIEvent -toUIEvent = unsafeCastGObject . toGObject - -instance UIEventClass UIEvent -instance EventClass UIEvent -instance GObjectClass UIEvent where - toGObject = GObject . castForeignPtr . unUIEvent - unsafeCastGObject = UIEvent . castForeignPtr . unGObject - -castToUIEvent :: GObjectClass obj => obj -> UIEvent -castToUIEvent = castTo gTypeUIEvent "UIEvent" - -gTypeUIEvent :: GType -gTypeUIEvent = - {# call fun unsafe webkit_dom_ui_event_get_type #} - --- ***************************************************************** MouseEvent - -{#pointer *WebKitDOMMouseEvent as MouseEvent foreign newtype #} deriving (Eq,Ord) - -mkMouseEvent = (MouseEvent, objectUnrefFromMainloop) -unMouseEvent (MouseEvent o) = o - -class UIEventClass o => MouseEventClass o -toMouseEvent :: MouseEventClass o => o -> MouseEvent -toMouseEvent = unsafeCastGObject . toGObject - -instance MouseEventClass MouseEvent -instance UIEventClass MouseEvent -instance EventClass MouseEvent -instance GObjectClass MouseEvent where - toGObject = GObject . castForeignPtr . unMouseEvent - unsafeCastGObject = MouseEvent . castForeignPtr . unGObject - -castToMouseEvent :: GObjectClass obj => obj -> MouseEvent -castToMouseEvent = castTo gTypeMouseEvent "MouseEvent" - -gTypeMouseEvent :: GType -gTypeMouseEvent = - {# call fun unsafe webkit_dom_mouse_event_get_type #} - --- ************************************************************** KeyboardEvent - -{#pointer *WebKitDOMKeyboardEvent as KeyboardEvent foreign newtype #} deriving (Eq,Ord) - -mkKeyboardEvent = (KeyboardEvent, objectUnrefFromMainloop) -unKeyboardEvent (KeyboardEvent o) = o - -class UIEventClass o => KeyboardEventClass o -toKeyboardEvent :: KeyboardEventClass o => o -> KeyboardEvent -toKeyboardEvent = unsafeCastGObject . toGObject - -instance KeyboardEventClass KeyboardEvent -instance UIEventClass KeyboardEvent -instance EventClass KeyboardEvent -instance GObjectClass KeyboardEvent where - toGObject = GObject . castForeignPtr . unKeyboardEvent - unsafeCastGObject = KeyboardEvent . castForeignPtr . unGObject - -castToKeyboardEvent :: GObjectClass obj => obj -> KeyboardEvent -castToKeyboardEvent = castTo gTypeKeyboardEvent "KeyboardEvent" - -gTypeKeyboardEvent :: GType -gTypeKeyboardEvent = - {# call fun unsafe webkit_dom_keyboard_event_get_type #} - --- **************************************************************** EventTarget - -{#pointer *WebKitDOMEventTarget as EventTarget foreign newtype #} deriving (Eq,Ord) - -mkEventTarget = (EventTarget, objectUnrefFromMainloop) -unEventTarget (EventTarget o) = o - -class GObjectClass o => EventTargetClass o -toEventTarget :: EventTargetClass o => o -> EventTarget -toEventTarget = unsafeCastGObject . toGObject - -instance EventTargetClass EventTarget -instance GObjectClass EventTarget where - toGObject = GObject . castForeignPtr . unEventTarget - unsafeCastGObject = EventTarget . castForeignPtr . unGObject - -castToEventTarget :: GObjectClass obj => obj -> EventTarget -castToEventTarget = castTo gTypeEventTarget "EventTarget" - -gTypeEventTarget :: GType -gTypeEventTarget = - {# call fun unsafe webkit_dom_event_target_get_type #} - --- ******************************************************************* FileList - -{#pointer *WebKitDOMFileList as FileList foreign newtype #} deriving (Eq,Ord) - -mkFileList = (FileList, objectUnrefFromMainloop) -unFileList (FileList o) = o - -class GObjectClass o => FileListClass o -toFileList :: FileListClass o => o -> FileList -toFileList = unsafeCastGObject . toGObject - -instance FileListClass FileList -instance GObjectClass FileList where - toGObject = GObject . castForeignPtr . unFileList - unsafeCastGObject = FileList . castForeignPtr . unGObject - -castToFileList :: GObjectClass obj => obj -> FileList -castToFileList = castTo gTypeFileList "FileList" - -gTypeFileList :: GType -gTypeFileList = - {# call fun unsafe webkit_dom_file_list_get_type #} - --- **************************************************************** Geolocation - -{#pointer *WebKitDOMGeolocation as Geolocation foreign newtype #} deriving (Eq,Ord) - -mkGeolocation = (Geolocation, objectUnrefFromMainloop) -unGeolocation (Geolocation o) = o - -class GObjectClass o => GeolocationClass o -toGeolocation :: GeolocationClass o => o -> Geolocation -toGeolocation = unsafeCastGObject . toGObject - -instance GeolocationClass Geolocation -instance GObjectClass Geolocation where - toGObject = GObject . castForeignPtr . unGeolocation - unsafeCastGObject = Geolocation . castForeignPtr . unGObject - -castToGeolocation :: GObjectClass obj => obj -> Geolocation -castToGeolocation = castTo gTypeGeolocation "Geolocation" - -gTypeGeolocation :: GType -gTypeGeolocation = - {# call fun unsafe webkit_dom_geolocation_get_type #} - --- ************************************************************* HTMLCollection - -{#pointer *WebKitDOMHTMLCollection as HTMLCollection foreign newtype #} deriving (Eq,Ord) - -mkHTMLCollection = (HTMLCollection, objectUnrefFromMainloop) -unHTMLCollection (HTMLCollection o) = o - -class GObjectClass o => HTMLCollectionClass o -toHTMLCollection :: HTMLCollectionClass o => o -> HTMLCollection -toHTMLCollection = unsafeCastGObject . toGObject - -instance HTMLCollectionClass HTMLCollection -instance GObjectClass HTMLCollection where - toGObject = GObject . castForeignPtr . unHTMLCollection - unsafeCastGObject = HTMLCollection . castForeignPtr . unGObject - -castToHTMLCollection :: GObjectClass obj => obj -> HTMLCollection -castToHTMLCollection = castTo gTypeHTMLCollection "HTMLCollection" - -gTypeHTMLCollection :: GType -gTypeHTMLCollection = - {# call fun unsafe webkit_dom_html_collection_get_type #} - --- ****************************************************** HTMLOptionsCollection - -{#pointer *WebKitDOMHTMLOptionsCollection as HTMLOptionsCollection foreign newtype #} deriving (Eq,Ord) - -mkHTMLOptionsCollection = (HTMLOptionsCollection, objectUnrefFromMainloop) -unHTMLOptionsCollection (HTMLOptionsCollection o) = o - -class HTMLCollectionClass o => HTMLOptionsCollectionClass o -toHTMLOptionsCollection :: HTMLOptionsCollectionClass o => o -> HTMLOptionsCollection -toHTMLOptionsCollection = unsafeCastGObject . toGObject - -instance HTMLOptionsCollectionClass HTMLOptionsCollection -instance HTMLCollectionClass HTMLOptionsCollection -instance GObjectClass HTMLOptionsCollection where - toGObject = GObject . castForeignPtr . unHTMLOptionsCollection - unsafeCastGObject = HTMLOptionsCollection . castForeignPtr . unGObject - -castToHTMLOptionsCollection :: GObjectClass obj => obj -> HTMLOptionsCollection -castToHTMLOptionsCollection = castTo gTypeHTMLOptionsCollection "HTMLOptionsCollection" - -gTypeHTMLOptionsCollection :: GType -gTypeHTMLOptionsCollection = - {# call fun unsafe webkit_dom_html_options_collection_get_type #} - --- ******************************************************************** History - -{#pointer *WebKitDOMHistory as History foreign newtype #} deriving (Eq,Ord) - -mkHistory = (History, objectUnrefFromMainloop) -unHistory (History o) = o - -class GObjectClass o => HistoryClass o -toHistory :: HistoryClass o => o -> History -toHistory = unsafeCastGObject . toGObject - -instance HistoryClass History -instance GObjectClass History where - toGObject = GObject . castForeignPtr . unHistory - unsafeCastGObject = History . castForeignPtr . unGObject - -castToHistory :: GObjectClass obj => obj -> History -castToHistory = castTo gTypeHistory "History" - -gTypeHistory :: GType -gTypeHistory = - {# call fun unsafe webkit_dom_history_get_type #} - --- ******************************************************************* Location - -{#pointer *WebKitDOMLocation as Location foreign newtype #} deriving (Eq,Ord) - -mkLocation = (Location, objectUnrefFromMainloop) -unLocation (Location o) = o - -class GObjectClass o => LocationClass o -toLocation :: LocationClass o => o -> Location -toLocation = unsafeCastGObject . toGObject - -instance LocationClass Location -instance GObjectClass Location where - toGObject = GObject . castForeignPtr . unLocation - unsafeCastGObject = Location . castForeignPtr . unGObject - -castToLocation :: GObjectClass obj => obj -> Location -castToLocation = castTo gTypeLocation "Location" - -gTypeLocation :: GType -gTypeLocation = - {# call fun unsafe webkit_dom_location_get_type #} - --- ***************************************************************** MediaError - -{#pointer *WebKitDOMMediaError as MediaError foreign newtype #} deriving (Eq,Ord) - -mkMediaError = (MediaError, objectUnrefFromMainloop) -unMediaError (MediaError o) = o - -class GObjectClass o => MediaErrorClass o -toMediaError :: MediaErrorClass o => o -> MediaError -toMediaError = unsafeCastGObject . toGObject - -instance MediaErrorClass MediaError -instance GObjectClass MediaError where - toGObject = GObject . castForeignPtr . unMediaError - unsafeCastGObject = MediaError . castForeignPtr . unGObject - -castToMediaError :: GObjectClass obj => obj -> MediaError -castToMediaError = castTo gTypeMediaError "MediaError" - -gTypeMediaError :: GType -gTypeMediaError = - {# call fun unsafe webkit_dom_media_error_get_type #} - --- ****************************************************************** MediaList - -{#pointer *WebKitDOMMediaList as MediaList foreign newtype #} deriving (Eq,Ord) - -mkMediaList = (MediaList, objectUnrefFromMainloop) -unMediaList (MediaList o) = o - -class GObjectClass o => MediaListClass o -toMediaList :: MediaListClass o => o -> MediaList -toMediaList = unsafeCastGObject . toGObject - -instance MediaListClass MediaList -instance GObjectClass MediaList where - toGObject = GObject . castForeignPtr . unMediaList - unsafeCastGObject = MediaList . castForeignPtr . unGObject - -castToMediaList :: GObjectClass obj => obj -> MediaList -castToMediaList = castTo gTypeMediaList "MediaList" - -gTypeMediaList :: GType -gTypeMediaList = - {# call fun unsafe webkit_dom_media_list_get_type #} - --- ************************************************************* MediaQueryList - -{#pointer *WebKitDOMMediaQueryList as MediaQueryList foreign newtype #} deriving (Eq,Ord) - -mkMediaQueryList = (MediaQueryList, objectUnrefFromMainloop) -unMediaQueryList (MediaQueryList o) = o - -class GObjectClass o => MediaQueryListClass o -toMediaQueryList :: MediaQueryListClass o => o -> MediaQueryList -toMediaQueryList = unsafeCastGObject . toGObject - -instance MediaQueryListClass MediaQueryList -instance GObjectClass MediaQueryList where - toGObject = GObject . castForeignPtr . unMediaQueryList - unsafeCastGObject = MediaQueryList . castForeignPtr . unGObject - -castToMediaQueryList :: GObjectClass obj => obj -> MediaQueryList -castToMediaQueryList = castTo gTypeMediaQueryList "MediaQueryList" - -gTypeMediaQueryList :: GType -gTypeMediaQueryList = - {# call fun unsafe webkit_dom_media_query_list_get_type #} - --- **************************************************************** MessagePort - -{#pointer *WebKitDOMMessagePort as MessagePort foreign newtype #} deriving (Eq,Ord) - -mkMessagePort = (MessagePort, objectUnrefFromMainloop) -unMessagePort (MessagePort o) = o - -class GObjectClass o => MessagePortClass o -toMessagePort :: MessagePortClass o => o -> MessagePort -toMessagePort = unsafeCastGObject . toGObject - -instance MessagePortClass MessagePort -instance GObjectClass MessagePort where - toGObject = GObject . castForeignPtr . unMessagePort - unsafeCastGObject = MessagePort . castForeignPtr . unGObject - -castToMessagePort :: GObjectClass obj => obj -> MessagePort -castToMessagePort = castTo gTypeMessagePort "MessagePort" - -gTypeMessagePort :: GType -gTypeMessagePort = - {# call fun unsafe webkit_dom_message_port_get_type #} - --- *************************************************************** NamedNodeMap - -{#pointer *WebKitDOMNamedNodeMap as NamedNodeMap foreign newtype #} deriving (Eq,Ord) - -mkNamedNodeMap = (NamedNodeMap, objectUnrefFromMainloop) -unNamedNodeMap (NamedNodeMap o) = o - -class GObjectClass o => NamedNodeMapClass o -toNamedNodeMap :: NamedNodeMapClass o => o -> NamedNodeMap -toNamedNodeMap = unsafeCastGObject . toGObject - -instance NamedNodeMapClass NamedNodeMap -instance GObjectClass NamedNodeMap where - toGObject = GObject . castForeignPtr . unNamedNodeMap - unsafeCastGObject = NamedNodeMap . castForeignPtr . unGObject - -castToNamedNodeMap :: GObjectClass obj => obj -> NamedNodeMap -castToNamedNodeMap = castTo gTypeNamedNodeMap "NamedNodeMap" - -gTypeNamedNodeMap :: GType -gTypeNamedNodeMap = - {# call fun unsafe webkit_dom_named_node_map_get_type #} - --- ****************************************************************** Navigator - -{#pointer *WebKitDOMNavigator as Navigator foreign newtype #} deriving (Eq,Ord) - -mkNavigator = (Navigator, objectUnrefFromMainloop) -unNavigator (Navigator o) = o - -class GObjectClass o => NavigatorClass o -toNavigator :: NavigatorClass o => o -> Navigator -toNavigator = unsafeCastGObject . toGObject - -instance NavigatorClass Navigator -instance GObjectClass Navigator where - toGObject = GObject . castForeignPtr . unNavigator - unsafeCastGObject = Navigator . castForeignPtr . unGObject - -castToNavigator :: GObjectClass obj => obj -> Navigator -castToNavigator = castTo gTypeNavigator "Navigator" - -gTypeNavigator :: GType -gTypeNavigator = - {# call fun unsafe webkit_dom_navigator_get_type #} - --- *********************************************************************** Node - -{#pointer *WebKitDOMNode as Node foreign newtype #} deriving (Eq,Ord) - -mkNode = (Node, objectUnrefFromMainloop) -unNode (Node o) = o - -class GObjectClass o => NodeClass o -toNode :: NodeClass o => o -> Node -toNode = unsafeCastGObject . toGObject - -instance NodeClass Node -instance GObjectClass Node where - toGObject = GObject . castForeignPtr . unNode - unsafeCastGObject = Node . castForeignPtr . unGObject - -castToNode :: GObjectClass obj => obj -> Node -castToNode = castTo gTypeNode "Node" - -gTypeNode :: GType -gTypeNode = - {# call fun unsafe webkit_dom_node_get_type #} - --- ******************************************************************** DOMAttr - -{#pointer *WebKitDOMAttr as DOMAttr foreign newtype #} deriving (Eq,Ord) - -mkDOMAttr = (DOMAttr, objectUnrefFromMainloop) -unDOMAttr (DOMAttr o) = o - -class NodeClass o => DOMAttrClass o -toDOMAttr :: DOMAttrClass o => o -> DOMAttr -toDOMAttr = unsafeCastGObject . toGObject - -instance DOMAttrClass DOMAttr -instance NodeClass DOMAttr -instance GObjectClass DOMAttr where - toGObject = GObject . castForeignPtr . unDOMAttr - unsafeCastGObject = DOMAttr . castForeignPtr . unGObject - -castToDOMAttr :: GObjectClass obj => obj -> DOMAttr -castToDOMAttr = castTo gTypeDOMAttr "DOMAttr" - -gTypeDOMAttr :: GType -gTypeDOMAttr = - {# call fun unsafe webkit_dom_attr_get_type #} - --- ************************************************************** CharacterData - -{#pointer *WebKitDOMCharacterData as CharacterData foreign newtype #} deriving (Eq,Ord) - -mkCharacterData = (CharacterData, objectUnrefFromMainloop) -unCharacterData (CharacterData o) = o - -class NodeClass o => CharacterDataClass o -toCharacterData :: CharacterDataClass o => o -> CharacterData -toCharacterData = unsafeCastGObject . toGObject - -instance CharacterDataClass CharacterData -instance NodeClass CharacterData -instance GObjectClass CharacterData where - toGObject = GObject . castForeignPtr . unCharacterData - unsafeCastGObject = CharacterData . castForeignPtr . unGObject - -castToCharacterData :: GObjectClass obj => obj -> CharacterData -castToCharacterData = castTo gTypeCharacterData "CharacterData" - -gTypeCharacterData :: GType -gTypeCharacterData = - {# call fun unsafe webkit_dom_character_data_get_type #} - --- ******************************************************************** Comment - -{#pointer *WebKitDOMComment as Comment foreign newtype #} deriving (Eq,Ord) - -mkComment = (Comment, objectUnrefFromMainloop) -unComment (Comment o) = o - -class CharacterDataClass o => CommentClass o -toComment :: CommentClass o => o -> Comment -toComment = unsafeCastGObject . toGObject - -instance CommentClass Comment -instance CharacterDataClass Comment -instance NodeClass Comment -instance GObjectClass Comment where - toGObject = GObject . castForeignPtr . unComment - unsafeCastGObject = Comment . castForeignPtr . unGObject - -castToComment :: GObjectClass obj => obj -> Comment -castToComment = castTo gTypeComment "Comment" - -gTypeComment :: GType -gTypeComment = - {# call fun unsafe webkit_dom_comment_get_type #} - --- *********************************************************************** Text - -{#pointer *WebKitDOMText as Text foreign newtype #} deriving (Eq,Ord) - -mkText = (Text, objectUnrefFromMainloop) -unText (Text o) = o - -class CharacterDataClass o => TextClass o -toText :: TextClass o => o -> Text -toText = unsafeCastGObject . toGObject - -instance TextClass Text -instance CharacterDataClass Text -instance NodeClass Text -instance GObjectClass Text where - toGObject = GObject . castForeignPtr . unText - unsafeCastGObject = Text . castForeignPtr . unGObject - -castToText :: GObjectClass obj => obj -> Text -castToText = castTo gTypeText "Text" - -gTypeText :: GType -gTypeText = - {# call fun unsafe webkit_dom_text_get_type #} - --- *************************************************************** CDATASection - -{#pointer *WebKitDOMCDATASection as CDATASection foreign newtype #} deriving (Eq,Ord) - -mkCDATASection = (CDATASection, objectUnrefFromMainloop) -unCDATASection (CDATASection o) = o - -class TextClass o => CDATASectionClass o -toCDATASection :: CDATASectionClass o => o -> CDATASection -toCDATASection = unsafeCastGObject . toGObject - -instance CDATASectionClass CDATASection -instance TextClass CDATASection -instance CharacterDataClass CDATASection -instance NodeClass CDATASection -instance GObjectClass CDATASection where - toGObject = GObject . castForeignPtr . unCDATASection - unsafeCastGObject = CDATASection . castForeignPtr . unGObject - -castToCDATASection :: GObjectClass obj => obj -> CDATASection -castToCDATASection = castTo gTypeCDATASection "CDATASection" - -gTypeCDATASection :: GType -gTypeCDATASection = - {# call fun unsafe webkit_dom_cdata_section_get_type #} - --- ******************************************************************* Document - -{#pointer *WebKitDOMDocument as Document foreign newtype #} deriving (Eq,Ord) - -mkDocument = (Document, objectUnrefFromMainloop) -unDocument (Document o) = o - -class NodeClass o => DocumentClass o -toDocument :: DocumentClass o => o -> Document -toDocument = unsafeCastGObject . toGObject - -instance DocumentClass Document -instance NodeClass Document -instance GObjectClass Document where - toGObject = GObject . castForeignPtr . unDocument - unsafeCastGObject = Document . castForeignPtr . unGObject - -castToDocument :: GObjectClass obj => obj -> Document -castToDocument = castTo gTypeDocument "Document" - -gTypeDocument :: GType -gTypeDocument = - {# call fun unsafe webkit_dom_document_get_type #} - --- *************************************************************** HTMLDocument - -{#pointer *WebKitDOMHTMLDocument as HTMLDocument foreign newtype #} deriving (Eq,Ord) - -mkHTMLDocument = (HTMLDocument, objectUnrefFromMainloop) -unHTMLDocument (HTMLDocument o) = o - -class DocumentClass o => HTMLDocumentClass o -toHTMLDocument :: HTMLDocumentClass o => o -> HTMLDocument -toHTMLDocument = unsafeCastGObject . toGObject - -instance HTMLDocumentClass HTMLDocument -instance DocumentClass HTMLDocument -instance NodeClass HTMLDocument -instance GObjectClass HTMLDocument where - toGObject = GObject . castForeignPtr . unHTMLDocument - unsafeCastGObject = HTMLDocument . castForeignPtr . unGObject - -castToHTMLDocument :: GObjectClass obj => obj -> HTMLDocument -castToHTMLDocument = castTo gTypeHTMLDocument "HTMLDocument" - -gTypeHTMLDocument :: GType -gTypeHTMLDocument = - {# call fun unsafe webkit_dom_html_document_get_type #} - --- *********************************************************** DocumentFragment - -{#pointer *WebKitDOMDocumentFragment as DocumentFragment foreign newtype #} deriving (Eq,Ord) - -mkDocumentFragment = (DocumentFragment, objectUnrefFromMainloop) -unDocumentFragment (DocumentFragment o) = o - -class NodeClass o => DocumentFragmentClass o -toDocumentFragment :: DocumentFragmentClass o => o -> DocumentFragment -toDocumentFragment = unsafeCastGObject . toGObject - -instance DocumentFragmentClass DocumentFragment -instance NodeClass DocumentFragment -instance GObjectClass DocumentFragment where - toGObject = GObject . castForeignPtr . unDocumentFragment - unsafeCastGObject = DocumentFragment . castForeignPtr . unGObject - -castToDocumentFragment :: GObjectClass obj => obj -> DocumentFragment -castToDocumentFragment = castTo gTypeDocumentFragment "DocumentFragment" - -gTypeDocumentFragment :: GType -gTypeDocumentFragment = - {# call fun unsafe webkit_dom_document_fragment_get_type #} - --- *************************************************************** DocumentType - -{#pointer *WebKitDOMDocumentType as DocumentType foreign newtype #} deriving (Eq,Ord) - -mkDocumentType = (DocumentType, objectUnrefFromMainloop) -unDocumentType (DocumentType o) = o - -class NodeClass o => DocumentTypeClass o -toDocumentType :: DocumentTypeClass o => o -> DocumentType -toDocumentType = unsafeCastGObject . toGObject - -instance DocumentTypeClass DocumentType -instance NodeClass DocumentType -instance GObjectClass DocumentType where - toGObject = GObject . castForeignPtr . unDocumentType - unsafeCastGObject = DocumentType . castForeignPtr . unGObject - -castToDocumentType :: GObjectClass obj => obj -> DocumentType -castToDocumentType = castTo gTypeDocumentType "DocumentType" - -gTypeDocumentType :: GType -gTypeDocumentType = - {# call fun unsafe webkit_dom_document_type_get_type #} - --- ******************************************************************** Element - -{#pointer *WebKitDOMElement as Element foreign newtype #} deriving (Eq,Ord) - -mkElement = (Element, objectUnrefFromMainloop) -unElement (Element o) = o - -class NodeClass o => ElementClass o -toElement :: ElementClass o => o -> Element -toElement = unsafeCastGObject . toGObject - -instance ElementClass Element -instance NodeClass Element -instance GObjectClass Element where - toGObject = GObject . castForeignPtr . unElement - unsafeCastGObject = Element . castForeignPtr . unGObject - -castToElement :: GObjectClass obj => obj -> Element -castToElement = castTo gTypeElement "Element" - -gTypeElement :: GType -gTypeElement = - {# call fun unsafe webkit_dom_element_get_type #} - --- **************************************************************** HTMLElement - -{#pointer *WebKitDOMHTMLElement as HTMLElement foreign newtype #} deriving (Eq,Ord) - -mkHTMLElement = (HTMLElement, objectUnrefFromMainloop) -unHTMLElement (HTMLElement o) = o - -class ElementClass o => HTMLElementClass o -toHTMLElement :: HTMLElementClass o => o -> HTMLElement -toHTMLElement = unsafeCastGObject . toGObject - -instance HTMLElementClass HTMLElement -instance ElementClass HTMLElement -instance NodeClass HTMLElement -instance GObjectClass HTMLElement where - toGObject = GObject . castForeignPtr . unHTMLElement - unsafeCastGObject = HTMLElement . castForeignPtr . unGObject - -castToHTMLElement :: GObjectClass obj => obj -> HTMLElement -castToHTMLElement = castTo gTypeHTMLElement "HTMLElement" - -gTypeHTMLElement :: GType -gTypeHTMLElement = - {# call fun unsafe webkit_dom_html_element_get_type #} - --- ********************************************************** HTMLAnchorElement - -{#pointer *WebKitDOMHTMLAnchorElement as HTMLAnchorElement foreign newtype #} deriving (Eq,Ord) - -mkHTMLAnchorElement = (HTMLAnchorElement, objectUnrefFromMainloop) -unHTMLAnchorElement (HTMLAnchorElement o) = o - -class HTMLElementClass o => HTMLAnchorElementClass o -toHTMLAnchorElement :: HTMLAnchorElementClass o => o -> HTMLAnchorElement -toHTMLAnchorElement = unsafeCastGObject . toGObject - -instance HTMLAnchorElementClass HTMLAnchorElement -instance HTMLElementClass HTMLAnchorElement -instance ElementClass HTMLAnchorElement -instance NodeClass HTMLAnchorElement -instance GObjectClass HTMLAnchorElement where - toGObject = GObject . castForeignPtr . unHTMLAnchorElement - unsafeCastGObject = HTMLAnchorElement . castForeignPtr . unGObject - -castToHTMLAnchorElement :: GObjectClass obj => obj -> HTMLAnchorElement -castToHTMLAnchorElement = castTo gTypeHTMLAnchorElement "HTMLAnchorElement" - -gTypeHTMLAnchorElement :: GType -gTypeHTMLAnchorElement = - {# call fun unsafe webkit_dom_html_anchor_element_get_type #} - --- ********************************************************** HTMLAppletElement - -{#pointer *WebKitDOMHTMLAppletElement as HTMLAppletElement foreign newtype #} deriving (Eq,Ord) - -mkHTMLAppletElement = (HTMLAppletElement, objectUnrefFromMainloop) -unHTMLAppletElement (HTMLAppletElement o) = o - -class HTMLElementClass o => HTMLAppletElementClass o -toHTMLAppletElement :: HTMLAppletElementClass o => o -> HTMLAppletElement -toHTMLAppletElement = unsafeCastGObject . toGObject - -instance HTMLAppletElementClass HTMLAppletElement -instance HTMLElementClass HTMLAppletElement -instance ElementClass HTMLAppletElement -instance NodeClass HTMLAppletElement -instance GObjectClass HTMLAppletElement where - toGObject = GObject . castForeignPtr . unHTMLAppletElement - unsafeCastGObject = HTMLAppletElement . castForeignPtr . unGObject - -castToHTMLAppletElement :: GObjectClass obj => obj -> HTMLAppletElement -castToHTMLAppletElement = castTo gTypeHTMLAppletElement "HTMLAppletElement" - -gTypeHTMLAppletElement :: GType -gTypeHTMLAppletElement = - {# call fun unsafe webkit_dom_html_applet_element_get_type #} - --- ************************************************************ HTMLAreaElement - -{#pointer *WebKitDOMHTMLAreaElement as HTMLAreaElement foreign newtype #} deriving (Eq,Ord) - -mkHTMLAreaElement = (HTMLAreaElement, objectUnrefFromMainloop) -unHTMLAreaElement (HTMLAreaElement o) = o - -class HTMLElementClass o => HTMLAreaElementClass o -toHTMLAreaElement :: HTMLAreaElementClass o => o -> HTMLAreaElement -toHTMLAreaElement = unsafeCastGObject . toGObject - -instance HTMLAreaElementClass HTMLAreaElement -instance HTMLElementClass HTMLAreaElement -instance ElementClass HTMLAreaElement -instance NodeClass HTMLAreaElement -instance GObjectClass HTMLAreaElement where - toGObject = GObject . castForeignPtr . unHTMLAreaElement - unsafeCastGObject = HTMLAreaElement . castForeignPtr . unGObject - -castToHTMLAreaElement :: GObjectClass obj => obj -> HTMLAreaElement -castToHTMLAreaElement = castTo gTypeHTMLAreaElement "HTMLAreaElement" - -gTypeHTMLAreaElement :: GType -gTypeHTMLAreaElement = - {# call fun unsafe webkit_dom_html_area_element_get_type #} - --- ************************************************************** HTMLBRElement - -{#pointer *WebKitDOMHTMLBRElement as HTMLBRElement foreign newtype #} deriving (Eq,Ord) - -mkHTMLBRElement = (HTMLBRElement, objectUnrefFromMainloop) -unHTMLBRElement (HTMLBRElement o) = o - -class HTMLElementClass o => HTMLBRElementClass o -toHTMLBRElement :: HTMLBRElementClass o => o -> HTMLBRElement -toHTMLBRElement = unsafeCastGObject . toGObject - -instance HTMLBRElementClass HTMLBRElement -instance HTMLElementClass HTMLBRElement -instance ElementClass HTMLBRElement -instance NodeClass HTMLBRElement -instance GObjectClass HTMLBRElement where - toGObject = GObject . castForeignPtr . unHTMLBRElement - unsafeCastGObject = HTMLBRElement . castForeignPtr . unGObject - -castToHTMLBRElement :: GObjectClass obj => obj -> HTMLBRElement -castToHTMLBRElement = castTo gTypeHTMLBRElement "HTMLBRElement" - -gTypeHTMLBRElement :: GType -gTypeHTMLBRElement = - {# call fun unsafe webkit_dom_htmlbr_element_get_type #} - --- ************************************************************ HTMLBaseElement - -{#pointer *WebKitDOMHTMLBaseElement as HTMLBaseElement foreign newtype #} deriving (Eq,Ord) - -mkHTMLBaseElement = (HTMLBaseElement, objectUnrefFromMainloop) -unHTMLBaseElement (HTMLBaseElement o) = o - -class HTMLElementClass o => HTMLBaseElementClass o -toHTMLBaseElement :: HTMLBaseElementClass o => o -> HTMLBaseElement -toHTMLBaseElement = unsafeCastGObject . toGObject - -instance HTMLBaseElementClass HTMLBaseElement -instance HTMLElementClass HTMLBaseElement -instance ElementClass HTMLBaseElement -instance NodeClass HTMLBaseElement -instance GObjectClass HTMLBaseElement where - toGObject = GObject . castForeignPtr . unHTMLBaseElement - unsafeCastGObject = HTMLBaseElement . castForeignPtr . unGObject - -castToHTMLBaseElement :: GObjectClass obj => obj -> HTMLBaseElement -castToHTMLBaseElement = castTo gTypeHTMLBaseElement "HTMLBaseElement" - -gTypeHTMLBaseElement :: GType -gTypeHTMLBaseElement = - {# call fun unsafe webkit_dom_html_base_element_get_type #} - --- ******************************************************** HTMLBaseFontElement - -{#pointer *WebKitDOMHTMLBaseFontElement as HTMLBaseFontElement foreign newtype #} deriving (Eq,Ord) - -mkHTMLBaseFontElement = (HTMLBaseFontElement, objectUnrefFromMainloop) -unHTMLBaseFontElement (HTMLBaseFontElement o) = o - -class HTMLElementClass o => HTMLBaseFontElementClass o -toHTMLBaseFontElement :: HTMLBaseFontElementClass o => o -> HTMLBaseFontElement -toHTMLBaseFontElement = unsafeCastGObject . toGObject - -instance HTMLBaseFontElementClass HTMLBaseFontElement -instance HTMLElementClass HTMLBaseFontElement -instance ElementClass HTMLBaseFontElement -instance NodeClass HTMLBaseFontElement -instance GObjectClass HTMLBaseFontElement where - toGObject = GObject . castForeignPtr . unHTMLBaseFontElement - unsafeCastGObject = HTMLBaseFontElement . castForeignPtr . unGObject - -castToHTMLBaseFontElement :: GObjectClass obj => obj -> HTMLBaseFontElement -castToHTMLBaseFontElement = castTo gTypeHTMLBaseFontElement "HTMLBaseFontElement" - -gTypeHTMLBaseFontElement :: GType -gTypeHTMLBaseFontElement = - {# call fun unsafe webkit_dom_html_base_font_element_get_type #} - --- ************************************************************ HTMLBodyElement - -{#pointer *WebKitDOMHTMLBodyElement as HTMLBodyElement foreign newtype #} deriving (Eq,Ord) - -mkHTMLBodyElement = (HTMLBodyElement, objectUnrefFromMainloop) -unHTMLBodyElement (HTMLBodyElement o) = o - -class HTMLElementClass o => HTMLBodyElementClass o -toHTMLBodyElement :: HTMLBodyElementClass o => o -> HTMLBodyElement -toHTMLBodyElement = unsafeCastGObject . toGObject - -instance HTMLBodyElementClass HTMLBodyElement -instance HTMLElementClass HTMLBodyElement -instance ElementClass HTMLBodyElement -instance NodeClass HTMLBodyElement -instance GObjectClass HTMLBodyElement where - toGObject = GObject . castForeignPtr . unHTMLBodyElement - unsafeCastGObject = HTMLBodyElement . castForeignPtr . unGObject - -castToHTMLBodyElement :: GObjectClass obj => obj -> HTMLBodyElement -castToHTMLBodyElement = castTo gTypeHTMLBodyElement "HTMLBodyElement" - -gTypeHTMLBodyElement :: GType -gTypeHTMLBodyElement = - {# call fun unsafe webkit_dom_html_body_element_get_type #} - --- ********************************************************** HTMLButtonElement - -{#pointer *WebKitDOMHTMLButtonElement as HTMLButtonElement foreign newtype #} deriving (Eq,Ord) - -mkHTMLButtonElement = (HTMLButtonElement, objectUnrefFromMainloop) -unHTMLButtonElement (HTMLButtonElement o) = o - -class HTMLElementClass o => HTMLButtonElementClass o -toHTMLButtonElement :: HTMLButtonElementClass o => o -> HTMLButtonElement -toHTMLButtonElement = unsafeCastGObject . toGObject - -instance HTMLButtonElementClass HTMLButtonElement -instance HTMLElementClass HTMLButtonElement -instance ElementClass HTMLButtonElement -instance NodeClass HTMLButtonElement -instance GObjectClass HTMLButtonElement where - toGObject = GObject . castForeignPtr . unHTMLButtonElement - unsafeCastGObject = HTMLButtonElement . castForeignPtr . unGObject - -castToHTMLButtonElement :: GObjectClass obj => obj -> HTMLButtonElement -castToHTMLButtonElement = castTo gTypeHTMLButtonElement "HTMLButtonElement" - -gTypeHTMLButtonElement :: GType -gTypeHTMLButtonElement = - {# call fun unsafe webkit_dom_html_button_element_get_type #} - --- ********************************************************** HTMLCanvasElement - -{#pointer *WebKitDOMHTMLCanvasElement as HTMLCanvasElement foreign newtype #} deriving (Eq,Ord) - -mkHTMLCanvasElement = (HTMLCanvasElement, objectUnrefFromMainloop) -unHTMLCanvasElement (HTMLCanvasElement o) = o - -class HTMLElementClass o => HTMLCanvasElementClass o -toHTMLCanvasElement :: HTMLCanvasElementClass o => o -> HTMLCanvasElement -toHTMLCanvasElement = unsafeCastGObject . toGObject - -instance HTMLCanvasElementClass HTMLCanvasElement -instance HTMLElementClass HTMLCanvasElement -instance ElementClass HTMLCanvasElement -instance NodeClass HTMLCanvasElement -instance GObjectClass HTMLCanvasElement where - toGObject = GObject . castForeignPtr . unHTMLCanvasElement - unsafeCastGObject = HTMLCanvasElement . castForeignPtr . unGObject - -castToHTMLCanvasElement :: GObjectClass obj => obj -> HTMLCanvasElement -castToHTMLCanvasElement = castTo gTypeHTMLCanvasElement "HTMLCanvasElement" - -gTypeHTMLCanvasElement :: GType -gTypeHTMLCanvasElement = - {# call fun unsafe webkit_dom_html_canvas_element_get_type #} - --- *********************************************************** HTMLDListElement - -{#pointer *WebKitDOMHTMLDListElement as HTMLDListElement foreign newtype #} deriving (Eq,Ord) - -mkHTMLDListElement = (HTMLDListElement, objectUnrefFromMainloop) -unHTMLDListElement (HTMLDListElement o) = o - -class HTMLElementClass o => HTMLDListElementClass o -toHTMLDListElement :: HTMLDListElementClass o => o -> HTMLDListElement -toHTMLDListElement = unsafeCastGObject . toGObject - -instance HTMLDListElementClass HTMLDListElement -instance HTMLElementClass HTMLDListElement -instance ElementClass HTMLDListElement -instance NodeClass HTMLDListElement -instance GObjectClass HTMLDListElement where - toGObject = GObject . castForeignPtr . unHTMLDListElement - unsafeCastGObject = HTMLDListElement . castForeignPtr . unGObject - -castToHTMLDListElement :: GObjectClass obj => obj -> HTMLDListElement -castToHTMLDListElement = castTo gTypeHTMLDListElement "HTMLDListElement" - -gTypeHTMLDListElement :: GType -gTypeHTMLDListElement = - {# call fun unsafe webkit_dom_htmld_list_element_get_type #} - --- ********************************************************* HTMLDetailsElement - -{#pointer *WebKitDOMHTMLDetailsElement as HTMLDetailsElement foreign newtype #} deriving (Eq,Ord) - -mkHTMLDetailsElement = (HTMLDetailsElement, objectUnrefFromMainloop) -unHTMLDetailsElement (HTMLDetailsElement o) = o - -class HTMLElementClass o => HTMLDetailsElementClass o -toHTMLDetailsElement :: HTMLDetailsElementClass o => o -> HTMLDetailsElement -toHTMLDetailsElement = unsafeCastGObject . toGObject - -instance HTMLDetailsElementClass HTMLDetailsElement -instance HTMLElementClass HTMLDetailsElement -instance ElementClass HTMLDetailsElement -instance NodeClass HTMLDetailsElement -instance GObjectClass HTMLDetailsElement where - toGObject = GObject . castForeignPtr . unHTMLDetailsElement - unsafeCastGObject = HTMLDetailsElement . castForeignPtr . unGObject - -castToHTMLDetailsElement :: GObjectClass obj => obj -> HTMLDetailsElement -castToHTMLDetailsElement = castTo gTypeHTMLDetailsElement "HTMLDetailsElement" - -gTypeHTMLDetailsElement :: GType -gTypeHTMLDetailsElement = - {# call fun unsafe webkit_dom_html_details_element_get_type #} - --- ******************************************************* HTMLDirectoryElement - -{#pointer *WebKitDOMHTMLDirectoryElement as HTMLDirectoryElement foreign newtype #} deriving (Eq,Ord) - -mkHTMLDirectoryElement = (HTMLDirectoryElement, objectUnrefFromMainloop) -unHTMLDirectoryElement (HTMLDirectoryElement o) = o - -class HTMLElementClass o => HTMLDirectoryElementClass o -toHTMLDirectoryElement :: HTMLDirectoryElementClass o => o -> HTMLDirectoryElement -toHTMLDirectoryElement = unsafeCastGObject . toGObject - -instance HTMLDirectoryElementClass HTMLDirectoryElement -instance HTMLElementClass HTMLDirectoryElement -instance ElementClass HTMLDirectoryElement -instance NodeClass HTMLDirectoryElement -instance GObjectClass HTMLDirectoryElement where - toGObject = GObject . castForeignPtr . unHTMLDirectoryElement - unsafeCastGObject = HTMLDirectoryElement . castForeignPtr . unGObject - -castToHTMLDirectoryElement :: GObjectClass obj => obj -> HTMLDirectoryElement -castToHTMLDirectoryElement = castTo gTypeHTMLDirectoryElement "HTMLDirectoryElement" - -gTypeHTMLDirectoryElement :: GType -gTypeHTMLDirectoryElement = - {# call fun unsafe webkit_dom_html_directory_element_get_type #} - --- ************************************************************* HTMLDivElement - -{#pointer *WebKitDOMHTMLDivElement as HTMLDivElement foreign newtype #} deriving (Eq,Ord) - -mkHTMLDivElement = (HTMLDivElement, objectUnrefFromMainloop) -unHTMLDivElement (HTMLDivElement o) = o - -class HTMLElementClass o => HTMLDivElementClass o -toHTMLDivElement :: HTMLDivElementClass o => o -> HTMLDivElement -toHTMLDivElement = unsafeCastGObject . toGObject - -instance HTMLDivElementClass HTMLDivElement -instance HTMLElementClass HTMLDivElement -instance ElementClass HTMLDivElement -instance NodeClass HTMLDivElement -instance GObjectClass HTMLDivElement where - toGObject = GObject . castForeignPtr . unHTMLDivElement - unsafeCastGObject = HTMLDivElement . castForeignPtr . unGObject - -castToHTMLDivElement :: GObjectClass obj => obj -> HTMLDivElement -castToHTMLDivElement = castTo gTypeHTMLDivElement "HTMLDivElement" - -gTypeHTMLDivElement :: GType -gTypeHTMLDivElement = - {# call fun unsafe webkit_dom_html_div_element_get_type #} - --- *********************************************************** HTMLEmbedElement - -{#pointer *WebKitDOMHTMLEmbedElement as HTMLEmbedElement foreign newtype #} deriving (Eq,Ord) - -mkHTMLEmbedElement = (HTMLEmbedElement, objectUnrefFromMainloop) -unHTMLEmbedElement (HTMLEmbedElement o) = o - -class HTMLElementClass o => HTMLEmbedElementClass o -toHTMLEmbedElement :: HTMLEmbedElementClass o => o -> HTMLEmbedElement -toHTMLEmbedElement = unsafeCastGObject . toGObject - -instance HTMLEmbedElementClass HTMLEmbedElement -instance HTMLElementClass HTMLEmbedElement -instance ElementClass HTMLEmbedElement -instance NodeClass HTMLEmbedElement -instance GObjectClass HTMLEmbedElement where - toGObject = GObject . castForeignPtr . unHTMLEmbedElement - unsafeCastGObject = HTMLEmbedElement . castForeignPtr . unGObject - -castToHTMLEmbedElement :: GObjectClass obj => obj -> HTMLEmbedElement -castToHTMLEmbedElement = castTo gTypeHTMLEmbedElement "HTMLEmbedElement" - -gTypeHTMLEmbedElement :: GType -gTypeHTMLEmbedElement = - {# call fun unsafe webkit_dom_html_embed_element_get_type #} - --- ******************************************************** HTMLFieldSetElement - -{#pointer *WebKitDOMHTMLFieldSetElement as HTMLFieldSetElement foreign newtype #} deriving (Eq,Ord) - -mkHTMLFieldSetElement = (HTMLFieldSetElement, objectUnrefFromMainloop) -unHTMLFieldSetElement (HTMLFieldSetElement o) = o - -class HTMLElementClass o => HTMLFieldSetElementClass o -toHTMLFieldSetElement :: HTMLFieldSetElementClass o => o -> HTMLFieldSetElement -toHTMLFieldSetElement = unsafeCastGObject . toGObject - -instance HTMLFieldSetElementClass HTMLFieldSetElement -instance HTMLElementClass HTMLFieldSetElement -instance ElementClass HTMLFieldSetElement -instance NodeClass HTMLFieldSetElement -instance GObjectClass HTMLFieldSetElement where - toGObject = GObject . castForeignPtr . unHTMLFieldSetElement - unsafeCastGObject = HTMLFieldSetElement . castForeignPtr . unGObject - -castToHTMLFieldSetElement :: GObjectClass obj => obj -> HTMLFieldSetElement -castToHTMLFieldSetElement = castTo gTypeHTMLFieldSetElement "HTMLFieldSetElement" - -gTypeHTMLFieldSetElement :: GType -gTypeHTMLFieldSetElement = - {# call fun unsafe webkit_dom_html_field_set_element_get_type #} - --- ************************************************************ HTMLFontElement - -{#pointer *WebKitDOMHTMLFontElement as HTMLFontElement foreign newtype #} deriving (Eq,Ord) - -mkHTMLFontElement = (HTMLFontElement, objectUnrefFromMainloop) -unHTMLFontElement (HTMLFontElement o) = o - -class HTMLElementClass o => HTMLFontElementClass o -toHTMLFontElement :: HTMLFontElementClass o => o -> HTMLFontElement -toHTMLFontElement = unsafeCastGObject . toGObject - -instance HTMLFontElementClass HTMLFontElement -instance HTMLElementClass HTMLFontElement -instance ElementClass HTMLFontElement -instance NodeClass HTMLFontElement -instance GObjectClass HTMLFontElement where - toGObject = GObject . castForeignPtr . unHTMLFontElement - unsafeCastGObject = HTMLFontElement . castForeignPtr . unGObject - -castToHTMLFontElement :: GObjectClass obj => obj -> HTMLFontElement -castToHTMLFontElement = castTo gTypeHTMLFontElement "HTMLFontElement" - -gTypeHTMLFontElement :: GType -gTypeHTMLFontElement = - {# call fun unsafe webkit_dom_html_font_element_get_type #} - --- ************************************************************ HTMLFormElement - -{#pointer *WebKitDOMHTMLFormElement as HTMLFormElement foreign newtype #} deriving (Eq,Ord) - -mkHTMLFormElement = (HTMLFormElement, objectUnrefFromMainloop) -unHTMLFormElement (HTMLFormElement o) = o - -class HTMLElementClass o => HTMLFormElementClass o -toHTMLFormElement :: HTMLFormElementClass o => o -> HTMLFormElement -toHTMLFormElement = unsafeCastGObject . toGObject - -instance HTMLFormElementClass HTMLFormElement -instance HTMLElementClass HTMLFormElement -instance ElementClass HTMLFormElement -instance NodeClass HTMLFormElement -instance GObjectClass HTMLFormElement where - toGObject = GObject . castForeignPtr . unHTMLFormElement - unsafeCastGObject = HTMLFormElement . castForeignPtr . unGObject - -castToHTMLFormElement :: GObjectClass obj => obj -> HTMLFormElement -castToHTMLFormElement = castTo gTypeHTMLFormElement "HTMLFormElement" - -gTypeHTMLFormElement :: GType -gTypeHTMLFormElement = - {# call fun unsafe webkit_dom_html_form_element_get_type #} - --- *********************************************************** HTMLFrameElement - -{#pointer *WebKitDOMHTMLFrameElement as HTMLFrameElement foreign newtype #} deriving (Eq,Ord) - -mkHTMLFrameElement = (HTMLFrameElement, objectUnrefFromMainloop) -unHTMLFrameElement (HTMLFrameElement o) = o - -class HTMLElementClass o => HTMLFrameElementClass o -toHTMLFrameElement :: HTMLFrameElementClass o => o -> HTMLFrameElement -toHTMLFrameElement = unsafeCastGObject . toGObject - -instance HTMLFrameElementClass HTMLFrameElement -instance HTMLElementClass HTMLFrameElement -instance ElementClass HTMLFrameElement -instance NodeClass HTMLFrameElement -instance GObjectClass HTMLFrameElement where - toGObject = GObject . castForeignPtr . unHTMLFrameElement - unsafeCastGObject = HTMLFrameElement . castForeignPtr . unGObject - -castToHTMLFrameElement :: GObjectClass obj => obj -> HTMLFrameElement -castToHTMLFrameElement = castTo gTypeHTMLFrameElement "HTMLFrameElement" - -gTypeHTMLFrameElement :: GType -gTypeHTMLFrameElement = - {# call fun unsafe webkit_dom_html_frame_element_get_type #} - --- ******************************************************** HTMLFrameSetElement - -{#pointer *WebKitDOMHTMLFrameSetElement as HTMLFrameSetElement foreign newtype #} deriving (Eq,Ord) - -mkHTMLFrameSetElement = (HTMLFrameSetElement, objectUnrefFromMainloop) -unHTMLFrameSetElement (HTMLFrameSetElement o) = o - -class HTMLElementClass o => HTMLFrameSetElementClass o -toHTMLFrameSetElement :: HTMLFrameSetElementClass o => o -> HTMLFrameSetElement -toHTMLFrameSetElement = unsafeCastGObject . toGObject - -instance HTMLFrameSetElementClass HTMLFrameSetElement -instance HTMLElementClass HTMLFrameSetElement -instance ElementClass HTMLFrameSetElement -instance NodeClass HTMLFrameSetElement -instance GObjectClass HTMLFrameSetElement where - toGObject = GObject . castForeignPtr . unHTMLFrameSetElement - unsafeCastGObject = HTMLFrameSetElement . castForeignPtr . unGObject - -castToHTMLFrameSetElement :: GObjectClass obj => obj -> HTMLFrameSetElement -castToHTMLFrameSetElement = castTo gTypeHTMLFrameSetElement "HTMLFrameSetElement" - -gTypeHTMLFrameSetElement :: GType -gTypeHTMLFrameSetElement = - {# call fun unsafe webkit_dom_html_frame_set_element_get_type #} - --- ************************************************************** HTMLHRElement - -{#pointer *WebKitDOMHTMLHRElement as HTMLHRElement foreign newtype #} deriving (Eq,Ord) - -mkHTMLHRElement = (HTMLHRElement, objectUnrefFromMainloop) -unHTMLHRElement (HTMLHRElement o) = o - -class HTMLElementClass o => HTMLHRElementClass o -toHTMLHRElement :: HTMLHRElementClass o => o -> HTMLHRElement -toHTMLHRElement = unsafeCastGObject . toGObject - -instance HTMLHRElementClass HTMLHRElement -instance HTMLElementClass HTMLHRElement -instance ElementClass HTMLHRElement -instance NodeClass HTMLHRElement -instance GObjectClass HTMLHRElement where - toGObject = GObject . castForeignPtr . unHTMLHRElement - unsafeCastGObject = HTMLHRElement . castForeignPtr . unGObject - -castToHTMLHRElement :: GObjectClass obj => obj -> HTMLHRElement -castToHTMLHRElement = castTo gTypeHTMLHRElement "HTMLHRElement" - -gTypeHTMLHRElement :: GType -gTypeHTMLHRElement = - {# call fun unsafe webkit_dom_htmlhr_element_get_type #} - --- ************************************************************ HTMLHeadElement - -{#pointer *WebKitDOMHTMLHeadElement as HTMLHeadElement foreign newtype #} deriving (Eq,Ord) - -mkHTMLHeadElement = (HTMLHeadElement, objectUnrefFromMainloop) -unHTMLHeadElement (HTMLHeadElement o) = o - -class HTMLElementClass o => HTMLHeadElementClass o -toHTMLHeadElement :: HTMLHeadElementClass o => o -> HTMLHeadElement -toHTMLHeadElement = unsafeCastGObject . toGObject - -instance HTMLHeadElementClass HTMLHeadElement -instance HTMLElementClass HTMLHeadElement -instance ElementClass HTMLHeadElement -instance NodeClass HTMLHeadElement -instance GObjectClass HTMLHeadElement where - toGObject = GObject . castForeignPtr . unHTMLHeadElement - unsafeCastGObject = HTMLHeadElement . castForeignPtr . unGObject - -castToHTMLHeadElement :: GObjectClass obj => obj -> HTMLHeadElement -castToHTMLHeadElement = castTo gTypeHTMLHeadElement "HTMLHeadElement" - -gTypeHTMLHeadElement :: GType -gTypeHTMLHeadElement = - {# call fun unsafe webkit_dom_html_head_element_get_type #} - --- ********************************************************* HTMLHeadingElement - -{#pointer *WebKitDOMHTMLHeadingElement as HTMLHeadingElement foreign newtype #} deriving (Eq,Ord) - -mkHTMLHeadingElement = (HTMLHeadingElement, objectUnrefFromMainloop) -unHTMLHeadingElement (HTMLHeadingElement o) = o - -class HTMLElementClass o => HTMLHeadingElementClass o -toHTMLHeadingElement :: HTMLHeadingElementClass o => o -> HTMLHeadingElement -toHTMLHeadingElement = unsafeCastGObject . toGObject - -instance HTMLHeadingElementClass HTMLHeadingElement -instance HTMLElementClass HTMLHeadingElement -instance ElementClass HTMLHeadingElement -instance NodeClass HTMLHeadingElement -instance GObjectClass HTMLHeadingElement where - toGObject = GObject . castForeignPtr . unHTMLHeadingElement - unsafeCastGObject = HTMLHeadingElement . castForeignPtr . unGObject - -castToHTMLHeadingElement :: GObjectClass obj => obj -> HTMLHeadingElement -castToHTMLHeadingElement = castTo gTypeHTMLHeadingElement "HTMLHeadingElement" - -gTypeHTMLHeadingElement :: GType -gTypeHTMLHeadingElement = - {# call fun unsafe webkit_dom_html_heading_element_get_type #} - --- ************************************************************ HTMLHtmlElement - -{#pointer *WebKitDOMHTMLHtmlElement as HTMLHtmlElement foreign newtype #} deriving (Eq,Ord) - -mkHTMLHtmlElement = (HTMLHtmlElement, objectUnrefFromMainloop) -unHTMLHtmlElement (HTMLHtmlElement o) = o - -class HTMLElementClass o => HTMLHtmlElementClass o -toHTMLHtmlElement :: HTMLHtmlElementClass o => o -> HTMLHtmlElement -toHTMLHtmlElement = unsafeCastGObject . toGObject - -instance HTMLHtmlElementClass HTMLHtmlElement -instance HTMLElementClass HTMLHtmlElement -instance ElementClass HTMLHtmlElement -instance NodeClass HTMLHtmlElement -instance GObjectClass HTMLHtmlElement where - toGObject = GObject . castForeignPtr . unHTMLHtmlElement - unsafeCastGObject = HTMLHtmlElement . castForeignPtr . unGObject - -castToHTMLHtmlElement :: GObjectClass obj => obj -> HTMLHtmlElement -castToHTMLHtmlElement = castTo gTypeHTMLHtmlElement "HTMLHtmlElement" - -gTypeHTMLHtmlElement :: GType -gTypeHTMLHtmlElement = - {# call fun unsafe webkit_dom_html_html_element_get_type #} - --- ********************************************************** HTMLIFrameElement - -{#pointer *WebKitDOMHTMLIFrameElement as HTMLIFrameElement foreign newtype #} deriving (Eq,Ord) - -mkHTMLIFrameElement = (HTMLIFrameElement, objectUnrefFromMainloop) -unHTMLIFrameElement (HTMLIFrameElement o) = o - -class HTMLElementClass o => HTMLIFrameElementClass o -toHTMLIFrameElement :: HTMLIFrameElementClass o => o -> HTMLIFrameElement -toHTMLIFrameElement = unsafeCastGObject . toGObject - -instance HTMLIFrameElementClass HTMLIFrameElement -instance HTMLElementClass HTMLIFrameElement -instance ElementClass HTMLIFrameElement -instance NodeClass HTMLIFrameElement -instance GObjectClass HTMLIFrameElement where - toGObject = GObject . castForeignPtr . unHTMLIFrameElement - unsafeCastGObject = HTMLIFrameElement . castForeignPtr . unGObject - -castToHTMLIFrameElement :: GObjectClass obj => obj -> HTMLIFrameElement -castToHTMLIFrameElement = castTo gTypeHTMLIFrameElement "HTMLIFrameElement" - -gTypeHTMLIFrameElement :: GType -gTypeHTMLIFrameElement = - {# call fun unsafe webkit_dom_html_iframe_element_get_type #} - --- *********************************************************** HTMLImageElement - -{#pointer *WebKitDOMHTMLImageElement as HTMLImageElement foreign newtype #} deriving (Eq,Ord) - -mkHTMLImageElement = (HTMLImageElement, objectUnrefFromMainloop) -unHTMLImageElement (HTMLImageElement o) = o - -class HTMLElementClass o => HTMLImageElementClass o -toHTMLImageElement :: HTMLImageElementClass o => o -> HTMLImageElement -toHTMLImageElement = unsafeCastGObject . toGObject - -instance HTMLImageElementClass HTMLImageElement -instance HTMLElementClass HTMLImageElement -instance ElementClass HTMLImageElement -instance NodeClass HTMLImageElement -instance GObjectClass HTMLImageElement where - toGObject = GObject . castForeignPtr . unHTMLImageElement - unsafeCastGObject = HTMLImageElement . castForeignPtr . unGObject - -castToHTMLImageElement :: GObjectClass obj => obj -> HTMLImageElement -castToHTMLImageElement = castTo gTypeHTMLImageElement "HTMLImageElement" - -gTypeHTMLImageElement :: GType -gTypeHTMLImageElement = - {# call fun unsafe webkit_dom_html_image_element_get_type #} - --- *********************************************************** HTMLInputElement - -{#pointer *WebKitDOMHTMLInputElement as HTMLInputElement foreign newtype #} deriving (Eq,Ord) - -mkHTMLInputElement = (HTMLInputElement, objectUnrefFromMainloop) -unHTMLInputElement (HTMLInputElement o) = o - -class HTMLElementClass o => HTMLInputElementClass o -toHTMLInputElement :: HTMLInputElementClass o => o -> HTMLInputElement -toHTMLInputElement = unsafeCastGObject . toGObject - -instance HTMLInputElementClass HTMLInputElement -instance HTMLElementClass HTMLInputElement -instance ElementClass HTMLInputElement -instance NodeClass HTMLInputElement -instance GObjectClass HTMLInputElement where - toGObject = GObject . castForeignPtr . unHTMLInputElement - unsafeCastGObject = HTMLInputElement . castForeignPtr . unGObject - -castToHTMLInputElement :: GObjectClass obj => obj -> HTMLInputElement -castToHTMLInputElement = castTo gTypeHTMLInputElement "HTMLInputElement" - -gTypeHTMLInputElement :: GType -gTypeHTMLInputElement = - {# call fun unsafe webkit_dom_html_input_element_get_type #} - --- ********************************************************** HTMLKeygenElement - -{#pointer *WebKitDOMHTMLKeygenElement as HTMLKeygenElement foreign newtype #} deriving (Eq,Ord) - -mkHTMLKeygenElement = (HTMLKeygenElement, objectUnrefFromMainloop) -unHTMLKeygenElement (HTMLKeygenElement o) = o - -class HTMLElementClass o => HTMLKeygenElementClass o -toHTMLKeygenElement :: HTMLKeygenElementClass o => o -> HTMLKeygenElement -toHTMLKeygenElement = unsafeCastGObject . toGObject - -instance HTMLKeygenElementClass HTMLKeygenElement -instance HTMLElementClass HTMLKeygenElement -instance ElementClass HTMLKeygenElement -instance NodeClass HTMLKeygenElement -instance GObjectClass HTMLKeygenElement where - toGObject = GObject . castForeignPtr . unHTMLKeygenElement - unsafeCastGObject = HTMLKeygenElement . castForeignPtr . unGObject - -castToHTMLKeygenElement :: GObjectClass obj => obj -> HTMLKeygenElement -castToHTMLKeygenElement = castTo gTypeHTMLKeygenElement "HTMLKeygenElement" - -gTypeHTMLKeygenElement :: GType -gTypeHTMLKeygenElement = - {# call fun unsafe webkit_dom_html_keygen_element_get_type #} - --- ************************************************************** HTMLLIElement - -{#pointer *WebKitDOMHTMLLIElement as HTMLLIElement foreign newtype #} deriving (Eq,Ord) - -mkHTMLLIElement = (HTMLLIElement, objectUnrefFromMainloop) -unHTMLLIElement (HTMLLIElement o) = o - -class HTMLElementClass o => HTMLLIElementClass o -toHTMLLIElement :: HTMLLIElementClass o => o -> HTMLLIElement -toHTMLLIElement = unsafeCastGObject . toGObject - -instance HTMLLIElementClass HTMLLIElement -instance HTMLElementClass HTMLLIElement -instance ElementClass HTMLLIElement -instance NodeClass HTMLLIElement -instance GObjectClass HTMLLIElement where - toGObject = GObject . castForeignPtr . unHTMLLIElement - unsafeCastGObject = HTMLLIElement . castForeignPtr . unGObject - -castToHTMLLIElement :: GObjectClass obj => obj -> HTMLLIElement -castToHTMLLIElement = castTo gTypeHTMLLIElement "HTMLLIElement" - -gTypeHTMLLIElement :: GType -gTypeHTMLLIElement = - {# call fun unsafe webkit_dom_htmlli_element_get_type #} - --- *********************************************************** HTMLLabelElement - -{#pointer *WebKitDOMHTMLLabelElement as HTMLLabelElement foreign newtype #} deriving (Eq,Ord) - -mkHTMLLabelElement = (HTMLLabelElement, objectUnrefFromMainloop) -unHTMLLabelElement (HTMLLabelElement o) = o - -class HTMLElementClass o => HTMLLabelElementClass o -toHTMLLabelElement :: HTMLLabelElementClass o => o -> HTMLLabelElement -toHTMLLabelElement = unsafeCastGObject . toGObject - -instance HTMLLabelElementClass HTMLLabelElement -instance HTMLElementClass HTMLLabelElement -instance ElementClass HTMLLabelElement -instance NodeClass HTMLLabelElement -instance GObjectClass HTMLLabelElement where - toGObject = GObject . castForeignPtr . unHTMLLabelElement - unsafeCastGObject = HTMLLabelElement . castForeignPtr . unGObject - -castToHTMLLabelElement :: GObjectClass obj => obj -> HTMLLabelElement -castToHTMLLabelElement = castTo gTypeHTMLLabelElement "HTMLLabelElement" - -gTypeHTMLLabelElement :: GType -gTypeHTMLLabelElement = - {# call fun unsafe webkit_dom_html_label_element_get_type #} - --- ********************************************************** HTMLLegendElement - -{#pointer *WebKitDOMHTMLLegendElement as HTMLLegendElement foreign newtype #} deriving (Eq,Ord) - -mkHTMLLegendElement = (HTMLLegendElement, objectUnrefFromMainloop) -unHTMLLegendElement (HTMLLegendElement o) = o - -class HTMLElementClass o => HTMLLegendElementClass o -toHTMLLegendElement :: HTMLLegendElementClass o => o -> HTMLLegendElement -toHTMLLegendElement = unsafeCastGObject . toGObject - -instance HTMLLegendElementClass HTMLLegendElement -instance HTMLElementClass HTMLLegendElement -instance ElementClass HTMLLegendElement -instance NodeClass HTMLLegendElement -instance GObjectClass HTMLLegendElement where - toGObject = GObject . castForeignPtr . unHTMLLegendElement - unsafeCastGObject = HTMLLegendElement . castForeignPtr . unGObject - -castToHTMLLegendElement :: GObjectClass obj => obj -> HTMLLegendElement -castToHTMLLegendElement = castTo gTypeHTMLLegendElement "HTMLLegendElement" - -gTypeHTMLLegendElement :: GType -gTypeHTMLLegendElement = - {# call fun unsafe webkit_dom_html_legend_element_get_type #} - --- ************************************************************ HTMLLinkElement - -{#pointer *WebKitDOMHTMLLinkElement as HTMLLinkElement foreign newtype #} deriving (Eq,Ord) - -mkHTMLLinkElement = (HTMLLinkElement, objectUnrefFromMainloop) -unHTMLLinkElement (HTMLLinkElement o) = o - -class HTMLElementClass o => HTMLLinkElementClass o -toHTMLLinkElement :: HTMLLinkElementClass o => o -> HTMLLinkElement -toHTMLLinkElement = unsafeCastGObject . toGObject - -instance HTMLLinkElementClass HTMLLinkElement -instance HTMLElementClass HTMLLinkElement -instance ElementClass HTMLLinkElement -instance NodeClass HTMLLinkElement -instance GObjectClass HTMLLinkElement where - toGObject = GObject . castForeignPtr . unHTMLLinkElement - unsafeCastGObject = HTMLLinkElement . castForeignPtr . unGObject - -castToHTMLLinkElement :: GObjectClass obj => obj -> HTMLLinkElement -castToHTMLLinkElement = castTo gTypeHTMLLinkElement "HTMLLinkElement" - -gTypeHTMLLinkElement :: GType -gTypeHTMLLinkElement = - {# call fun unsafe webkit_dom_html_link_element_get_type #} - --- ************************************************************* HTMLMapElement - -{#pointer *WebKitDOMHTMLMapElement as HTMLMapElement foreign newtype #} deriving (Eq,Ord) - -mkHTMLMapElement = (HTMLMapElement, objectUnrefFromMainloop) -unHTMLMapElement (HTMLMapElement o) = o - -class HTMLElementClass o => HTMLMapElementClass o -toHTMLMapElement :: HTMLMapElementClass o => o -> HTMLMapElement -toHTMLMapElement = unsafeCastGObject . toGObject - -instance HTMLMapElementClass HTMLMapElement -instance HTMLElementClass HTMLMapElement -instance ElementClass HTMLMapElement -instance NodeClass HTMLMapElement -instance GObjectClass HTMLMapElement where - toGObject = GObject . castForeignPtr . unHTMLMapElement - unsafeCastGObject = HTMLMapElement . castForeignPtr . unGObject - -castToHTMLMapElement :: GObjectClass obj => obj -> HTMLMapElement -castToHTMLMapElement = castTo gTypeHTMLMapElement "HTMLMapElement" - -gTypeHTMLMapElement :: GType -gTypeHTMLMapElement = - {# call fun unsafe webkit_dom_html_map_element_get_type #} - --- ********************************************************* HTMLMarqueeElement - -{#pointer *WebKitDOMHTMLMarqueeElement as HTMLMarqueeElement foreign newtype #} deriving (Eq,Ord) - -mkHTMLMarqueeElement = (HTMLMarqueeElement, objectUnrefFromMainloop) -unHTMLMarqueeElement (HTMLMarqueeElement o) = o - -class HTMLElementClass o => HTMLMarqueeElementClass o -toHTMLMarqueeElement :: HTMLMarqueeElementClass o => o -> HTMLMarqueeElement -toHTMLMarqueeElement = unsafeCastGObject . toGObject - -instance HTMLMarqueeElementClass HTMLMarqueeElement -instance HTMLElementClass HTMLMarqueeElement -instance ElementClass HTMLMarqueeElement -instance NodeClass HTMLMarqueeElement -instance GObjectClass HTMLMarqueeElement where - toGObject = GObject . castForeignPtr . unHTMLMarqueeElement - unsafeCastGObject = HTMLMarqueeElement . castForeignPtr . unGObject - -castToHTMLMarqueeElement :: GObjectClass obj => obj -> HTMLMarqueeElement -castToHTMLMarqueeElement = castTo gTypeHTMLMarqueeElement "HTMLMarqueeElement" - -gTypeHTMLMarqueeElement :: GType -gTypeHTMLMarqueeElement = - {# call fun unsafe webkit_dom_html_marquee_element_get_type #} - --- *********************************************************** HTMLMediaElement - -{#pointer *WebKitDOMHTMLMediaElement as HTMLMediaElement foreign newtype #} deriving (Eq,Ord) - -mkHTMLMediaElement = (HTMLMediaElement, objectUnrefFromMainloop) -unHTMLMediaElement (HTMLMediaElement o) = o - -class HTMLElementClass o => HTMLMediaElementClass o -toHTMLMediaElement :: HTMLMediaElementClass o => o -> HTMLMediaElement -toHTMLMediaElement = unsafeCastGObject . toGObject - -instance HTMLMediaElementClass HTMLMediaElement -instance HTMLElementClass HTMLMediaElement -instance ElementClass HTMLMediaElement -instance NodeClass HTMLMediaElement -instance GObjectClass HTMLMediaElement where - toGObject = GObject . castForeignPtr . unHTMLMediaElement - unsafeCastGObject = HTMLMediaElement . castForeignPtr . unGObject - -castToHTMLMediaElement :: GObjectClass obj => obj -> HTMLMediaElement -castToHTMLMediaElement = castTo gTypeHTMLMediaElement "HTMLMediaElement" - -gTypeHTMLMediaElement :: GType -gTypeHTMLMediaElement = - {# call fun unsafe webkit_dom_html_media_element_get_type #} - --- *********************************************************** HTMLAudioElement - -{#pointer *WebKitDOMHTMLAudioElement as HTMLAudioElement foreign newtype #} deriving (Eq,Ord) - -mkHTMLAudioElement = (HTMLAudioElement, objectUnrefFromMainloop) -unHTMLAudioElement (HTMLAudioElement o) = o - -class HTMLMediaElementClass o => HTMLAudioElementClass o -toHTMLAudioElement :: HTMLAudioElementClass o => o -> HTMLAudioElement -toHTMLAudioElement = unsafeCastGObject . toGObject - -instance HTMLAudioElementClass HTMLAudioElement -instance HTMLMediaElementClass HTMLAudioElement -instance HTMLElementClass HTMLAudioElement -instance ElementClass HTMLAudioElement -instance NodeClass HTMLAudioElement -instance GObjectClass HTMLAudioElement where - toGObject = GObject . castForeignPtr . unHTMLAudioElement - unsafeCastGObject = HTMLAudioElement . castForeignPtr . unGObject - -castToHTMLAudioElement :: GObjectClass obj => obj -> HTMLAudioElement -castToHTMLAudioElement = castTo gTypeHTMLAudioElement "HTMLAudioElement" - -gTypeHTMLAudioElement :: GType -gTypeHTMLAudioElement = - {# call fun unsafe webkit_dom_html_audio_element_get_type #} - --- *********************************************************** HTMLVideoElement - -{#pointer *WebKitDOMHTMLVideoElement as HTMLVideoElement foreign newtype #} deriving (Eq,Ord) - -mkHTMLVideoElement = (HTMLVideoElement, objectUnrefFromMainloop) -unHTMLVideoElement (HTMLVideoElement o) = o - -class HTMLMediaElementClass o => HTMLVideoElementClass o -toHTMLVideoElement :: HTMLVideoElementClass o => o -> HTMLVideoElement -toHTMLVideoElement = unsafeCastGObject . toGObject - -instance HTMLVideoElementClass HTMLVideoElement -instance HTMLMediaElementClass HTMLVideoElement -instance HTMLElementClass HTMLVideoElement -instance ElementClass HTMLVideoElement -instance NodeClass HTMLVideoElement -instance GObjectClass HTMLVideoElement where - toGObject = GObject . castForeignPtr . unHTMLVideoElement - unsafeCastGObject = HTMLVideoElement . castForeignPtr . unGObject - -castToHTMLVideoElement :: GObjectClass obj => obj -> HTMLVideoElement -castToHTMLVideoElement = castTo gTypeHTMLVideoElement "HTMLVideoElement" - -gTypeHTMLVideoElement :: GType -gTypeHTMLVideoElement = - {# call fun unsafe webkit_dom_html_video_element_get_type #} - --- ************************************************************ HTMLMenuElement - -{#pointer *WebKitDOMHTMLMenuElement as HTMLMenuElement foreign newtype #} deriving (Eq,Ord) - -mkHTMLMenuElement = (HTMLMenuElement, objectUnrefFromMainloop) -unHTMLMenuElement (HTMLMenuElement o) = o - -class HTMLElementClass o => HTMLMenuElementClass o -toHTMLMenuElement :: HTMLMenuElementClass o => o -> HTMLMenuElement -toHTMLMenuElement = unsafeCastGObject . toGObject - -instance HTMLMenuElementClass HTMLMenuElement -instance HTMLElementClass HTMLMenuElement -instance ElementClass HTMLMenuElement -instance NodeClass HTMLMenuElement -instance GObjectClass HTMLMenuElement where - toGObject = GObject . castForeignPtr . unHTMLMenuElement - unsafeCastGObject = HTMLMenuElement . castForeignPtr . unGObject - -castToHTMLMenuElement :: GObjectClass obj => obj -> HTMLMenuElement -castToHTMLMenuElement = castTo gTypeHTMLMenuElement "HTMLMenuElement" - -gTypeHTMLMenuElement :: GType -gTypeHTMLMenuElement = - {# call fun unsafe webkit_dom_html_menu_element_get_type #} - --- ************************************************************ HTMLMetaElement - -{#pointer *WebKitDOMHTMLMetaElement as HTMLMetaElement foreign newtype #} deriving (Eq,Ord) - -mkHTMLMetaElement = (HTMLMetaElement, objectUnrefFromMainloop) -unHTMLMetaElement (HTMLMetaElement o) = o - -class HTMLElementClass o => HTMLMetaElementClass o -toHTMLMetaElement :: HTMLMetaElementClass o => o -> HTMLMetaElement -toHTMLMetaElement = unsafeCastGObject . toGObject - -instance HTMLMetaElementClass HTMLMetaElement -instance HTMLElementClass HTMLMetaElement -instance ElementClass HTMLMetaElement -instance NodeClass HTMLMetaElement -instance GObjectClass HTMLMetaElement where - toGObject = GObject . castForeignPtr . unHTMLMetaElement - unsafeCastGObject = HTMLMetaElement . castForeignPtr . unGObject - -castToHTMLMetaElement :: GObjectClass obj => obj -> HTMLMetaElement -castToHTMLMetaElement = castTo gTypeHTMLMetaElement "HTMLMetaElement" - -gTypeHTMLMetaElement :: GType -gTypeHTMLMetaElement = - {# call fun unsafe webkit_dom_html_meta_element_get_type #} - --- ************************************************************* HTMLModElement - -{#pointer *WebKitDOMHTMLModElement as HTMLModElement foreign newtype #} deriving (Eq,Ord) - -mkHTMLModElement = (HTMLModElement, objectUnrefFromMainloop) -unHTMLModElement (HTMLModElement o) = o - -class HTMLElementClass o => HTMLModElementClass o -toHTMLModElement :: HTMLModElementClass o => o -> HTMLModElement -toHTMLModElement = unsafeCastGObject . toGObject - -instance HTMLModElementClass HTMLModElement -instance HTMLElementClass HTMLModElement -instance ElementClass HTMLModElement -instance NodeClass HTMLModElement -instance GObjectClass HTMLModElement where - toGObject = GObject . castForeignPtr . unHTMLModElement - unsafeCastGObject = HTMLModElement . castForeignPtr . unGObject - -castToHTMLModElement :: GObjectClass obj => obj -> HTMLModElement -castToHTMLModElement = castTo gTypeHTMLModElement "HTMLModElement" - -gTypeHTMLModElement :: GType -gTypeHTMLModElement = - {# call fun unsafe webkit_dom_html_mod_element_get_type #} - --- *********************************************************** HTMLOListElement - -{#pointer *WebKitDOMHTMLOListElement as HTMLOListElement foreign newtype #} deriving (Eq,Ord) - -mkHTMLOListElement = (HTMLOListElement, objectUnrefFromMainloop) -unHTMLOListElement (HTMLOListElement o) = o - -class HTMLElementClass o => HTMLOListElementClass o -toHTMLOListElement :: HTMLOListElementClass o => o -> HTMLOListElement -toHTMLOListElement = unsafeCastGObject . toGObject - -instance HTMLOListElementClass HTMLOListElement -instance HTMLElementClass HTMLOListElement -instance ElementClass HTMLOListElement -instance NodeClass HTMLOListElement -instance GObjectClass HTMLOListElement where - toGObject = GObject . castForeignPtr . unHTMLOListElement - unsafeCastGObject = HTMLOListElement . castForeignPtr . unGObject - -castToHTMLOListElement :: GObjectClass obj => obj -> HTMLOListElement -castToHTMLOListElement = castTo gTypeHTMLOListElement "HTMLOListElement" - -gTypeHTMLOListElement :: GType -gTypeHTMLOListElement = - {# call fun unsafe webkit_dom_htmlo_list_element_get_type #} - --- ********************************************************** HTMLObjectElement - -{#pointer *WebKitDOMHTMLObjectElement as HTMLObjectElement foreign newtype #} deriving (Eq,Ord) - -mkHTMLObjectElement = (HTMLObjectElement, objectUnrefFromMainloop) -unHTMLObjectElement (HTMLObjectElement o) = o - -class HTMLElementClass o => HTMLObjectElementClass o -toHTMLObjectElement :: HTMLObjectElementClass o => o -> HTMLObjectElement -toHTMLObjectElement = unsafeCastGObject . toGObject - -instance HTMLObjectElementClass HTMLObjectElement -instance HTMLElementClass HTMLObjectElement -instance ElementClass HTMLObjectElement -instance NodeClass HTMLObjectElement -instance GObjectClass HTMLObjectElement where - toGObject = GObject . castForeignPtr . unHTMLObjectElement - unsafeCastGObject = HTMLObjectElement . castForeignPtr . unGObject - -castToHTMLObjectElement :: GObjectClass obj => obj -> HTMLObjectElement -castToHTMLObjectElement = castTo gTypeHTMLObjectElement "HTMLObjectElement" - -gTypeHTMLObjectElement :: GType -gTypeHTMLObjectElement = - {# call fun unsafe webkit_dom_html_object_element_get_type #} - --- ******************************************************** HTMLOptGroupElement - -{#pointer *WebKitDOMHTMLOptGroupElement as HTMLOptGroupElement foreign newtype #} deriving (Eq,Ord) - -mkHTMLOptGroupElement = (HTMLOptGroupElement, objectUnrefFromMainloop) -unHTMLOptGroupElement (HTMLOptGroupElement o) = o - -class HTMLElementClass o => HTMLOptGroupElementClass o -toHTMLOptGroupElement :: HTMLOptGroupElementClass o => o -> HTMLOptGroupElement -toHTMLOptGroupElement = unsafeCastGObject . toGObject - -instance HTMLOptGroupElementClass HTMLOptGroupElement -instance HTMLElementClass HTMLOptGroupElement -instance ElementClass HTMLOptGroupElement -instance NodeClass HTMLOptGroupElement -instance GObjectClass HTMLOptGroupElement where - toGObject = GObject . castForeignPtr . unHTMLOptGroupElement - unsafeCastGObject = HTMLOptGroupElement . castForeignPtr . unGObject - -castToHTMLOptGroupElement :: GObjectClass obj => obj -> HTMLOptGroupElement -castToHTMLOptGroupElement = castTo gTypeHTMLOptGroupElement "HTMLOptGroupElement" - -gTypeHTMLOptGroupElement :: GType -gTypeHTMLOptGroupElement = - {# call fun unsafe webkit_dom_html_opt_group_element_get_type #} - --- ********************************************************** HTMLOptionElement - -{#pointer *WebKitDOMHTMLOptionElement as HTMLOptionElement foreign newtype #} deriving (Eq,Ord) - -mkHTMLOptionElement = (HTMLOptionElement, objectUnrefFromMainloop) -unHTMLOptionElement (HTMLOptionElement o) = o - -class HTMLElementClass o => HTMLOptionElementClass o -toHTMLOptionElement :: HTMLOptionElementClass o => o -> HTMLOptionElement -toHTMLOptionElement = unsafeCastGObject . toGObject - -instance HTMLOptionElementClass HTMLOptionElement -instance HTMLElementClass HTMLOptionElement -instance ElementClass HTMLOptionElement -instance NodeClass HTMLOptionElement -instance GObjectClass HTMLOptionElement where - toGObject = GObject . castForeignPtr . unHTMLOptionElement - unsafeCastGObject = HTMLOptionElement . castForeignPtr . unGObject - -castToHTMLOptionElement :: GObjectClass obj => obj -> HTMLOptionElement -castToHTMLOptionElement = castTo gTypeHTMLOptionElement "HTMLOptionElement" - -gTypeHTMLOptionElement :: GType -gTypeHTMLOptionElement = - {# call fun unsafe webkit_dom_html_option_element_get_type #} - --- ******************************************************* HTMLParagraphElement - -{#pointer *WebKitDOMHTMLParagraphElement as HTMLParagraphElement foreign newtype #} deriving (Eq,Ord) - -mkHTMLParagraphElement = (HTMLParagraphElement, objectUnrefFromMainloop) -unHTMLParagraphElement (HTMLParagraphElement o) = o - -class HTMLElementClass o => HTMLParagraphElementClass o -toHTMLParagraphElement :: HTMLParagraphElementClass o => o -> HTMLParagraphElement -toHTMLParagraphElement = unsafeCastGObject . toGObject - -instance HTMLParagraphElementClass HTMLParagraphElement -instance HTMLElementClass HTMLParagraphElement -instance ElementClass HTMLParagraphElement -instance NodeClass HTMLParagraphElement -instance GObjectClass HTMLParagraphElement where - toGObject = GObject . castForeignPtr . unHTMLParagraphElement - unsafeCastGObject = HTMLParagraphElement . castForeignPtr . unGObject - -castToHTMLParagraphElement :: GObjectClass obj => obj -> HTMLParagraphElement -castToHTMLParagraphElement = castTo gTypeHTMLParagraphElement "HTMLParagraphElement" - -gTypeHTMLParagraphElement :: GType -gTypeHTMLParagraphElement = - {# call fun unsafe webkit_dom_html_paragraph_element_get_type #} - --- *********************************************************** HTMLParamElement - -{#pointer *WebKitDOMHTMLParamElement as HTMLParamElement foreign newtype #} deriving (Eq,Ord) - -mkHTMLParamElement = (HTMLParamElement, objectUnrefFromMainloop) -unHTMLParamElement (HTMLParamElement o) = o - -class HTMLElementClass o => HTMLParamElementClass o -toHTMLParamElement :: HTMLParamElementClass o => o -> HTMLParamElement -toHTMLParamElement = unsafeCastGObject . toGObject - -instance HTMLParamElementClass HTMLParamElement -instance HTMLElementClass HTMLParamElement -instance ElementClass HTMLParamElement -instance NodeClass HTMLParamElement -instance GObjectClass HTMLParamElement where - toGObject = GObject . castForeignPtr . unHTMLParamElement - unsafeCastGObject = HTMLParamElement . castForeignPtr . unGObject - -castToHTMLParamElement :: GObjectClass obj => obj -> HTMLParamElement -castToHTMLParamElement = castTo gTypeHTMLParamElement "HTMLParamElement" - -gTypeHTMLParamElement :: GType -gTypeHTMLParamElement = - {# call fun unsafe webkit_dom_html_param_element_get_type #} - --- ************************************************************* HTMLPreElement - -{#pointer *WebKitDOMHTMLPreElement as HTMLPreElement foreign newtype #} deriving (Eq,Ord) - -mkHTMLPreElement = (HTMLPreElement, objectUnrefFromMainloop) -unHTMLPreElement (HTMLPreElement o) = o - -class HTMLElementClass o => HTMLPreElementClass o -toHTMLPreElement :: HTMLPreElementClass o => o -> HTMLPreElement -toHTMLPreElement = unsafeCastGObject . toGObject - -instance HTMLPreElementClass HTMLPreElement -instance HTMLElementClass HTMLPreElement -instance ElementClass HTMLPreElement -instance NodeClass HTMLPreElement -instance GObjectClass HTMLPreElement where - toGObject = GObject . castForeignPtr . unHTMLPreElement - unsafeCastGObject = HTMLPreElement . castForeignPtr . unGObject - -castToHTMLPreElement :: GObjectClass obj => obj -> HTMLPreElement -castToHTMLPreElement = castTo gTypeHTMLPreElement "HTMLPreElement" - -gTypeHTMLPreElement :: GType -gTypeHTMLPreElement = - {# call fun unsafe webkit_dom_html_pre_element_get_type #} - --- *********************************************************** HTMLQuoteElement - -{#pointer *WebKitDOMHTMLQuoteElement as HTMLQuoteElement foreign newtype #} deriving (Eq,Ord) - -mkHTMLQuoteElement = (HTMLQuoteElement, objectUnrefFromMainloop) -unHTMLQuoteElement (HTMLQuoteElement o) = o - -class HTMLElementClass o => HTMLQuoteElementClass o -toHTMLQuoteElement :: HTMLQuoteElementClass o => o -> HTMLQuoteElement -toHTMLQuoteElement = unsafeCastGObject . toGObject - -instance HTMLQuoteElementClass HTMLQuoteElement -instance HTMLElementClass HTMLQuoteElement -instance ElementClass HTMLQuoteElement -instance NodeClass HTMLQuoteElement -instance GObjectClass HTMLQuoteElement where - toGObject = GObject . castForeignPtr . unHTMLQuoteElement - unsafeCastGObject = HTMLQuoteElement . castForeignPtr . unGObject - -castToHTMLQuoteElement :: GObjectClass obj => obj -> HTMLQuoteElement -castToHTMLQuoteElement = castTo gTypeHTMLQuoteElement "HTMLQuoteElement" - -gTypeHTMLQuoteElement :: GType -gTypeHTMLQuoteElement = - {# call fun unsafe webkit_dom_html_quote_element_get_type #} - --- ********************************************************** HTMLScriptElement - -{#pointer *WebKitDOMHTMLScriptElement as HTMLScriptElement foreign newtype #} deriving (Eq,Ord) - -mkHTMLScriptElement = (HTMLScriptElement, objectUnrefFromMainloop) -unHTMLScriptElement (HTMLScriptElement o) = o - -class HTMLElementClass o => HTMLScriptElementClass o -toHTMLScriptElement :: HTMLScriptElementClass o => o -> HTMLScriptElement -toHTMLScriptElement = unsafeCastGObject . toGObject - -instance HTMLScriptElementClass HTMLScriptElement -instance HTMLElementClass HTMLScriptElement -instance ElementClass HTMLScriptElement -instance NodeClass HTMLScriptElement -instance GObjectClass HTMLScriptElement where - toGObject = GObject . castForeignPtr . unHTMLScriptElement - unsafeCastGObject = HTMLScriptElement . castForeignPtr . unGObject - -castToHTMLScriptElement :: GObjectClass obj => obj -> HTMLScriptElement -castToHTMLScriptElement = castTo gTypeHTMLScriptElement "HTMLScriptElement" - -gTypeHTMLScriptElement :: GType -gTypeHTMLScriptElement = - {# call fun unsafe webkit_dom_html_script_element_get_type #} - --- ********************************************************** HTMLSelectElement - -{#pointer *WebKitDOMHTMLSelectElement as HTMLSelectElement foreign newtype #} deriving (Eq,Ord) - -mkHTMLSelectElement = (HTMLSelectElement, objectUnrefFromMainloop) -unHTMLSelectElement (HTMLSelectElement o) = o - -class HTMLElementClass o => HTMLSelectElementClass o -toHTMLSelectElement :: HTMLSelectElementClass o => o -> HTMLSelectElement -toHTMLSelectElement = unsafeCastGObject . toGObject - -instance HTMLSelectElementClass HTMLSelectElement -instance HTMLElementClass HTMLSelectElement -instance ElementClass HTMLSelectElement -instance NodeClass HTMLSelectElement -instance GObjectClass HTMLSelectElement where - toGObject = GObject . castForeignPtr . unHTMLSelectElement - unsafeCastGObject = HTMLSelectElement . castForeignPtr . unGObject - -castToHTMLSelectElement :: GObjectClass obj => obj -> HTMLSelectElement -castToHTMLSelectElement = castTo gTypeHTMLSelectElement "HTMLSelectElement" - -gTypeHTMLSelectElement :: GType -gTypeHTMLSelectElement = - {# call fun unsafe webkit_dom_html_select_element_get_type #} - --- *********************************************************** HTMLStyleElement - -{#pointer *WebKitDOMHTMLStyleElement as HTMLStyleElement foreign newtype #} deriving (Eq,Ord) - -mkHTMLStyleElement = (HTMLStyleElement, objectUnrefFromMainloop) -unHTMLStyleElement (HTMLStyleElement o) = o - -class HTMLElementClass o => HTMLStyleElementClass o -toHTMLStyleElement :: HTMLStyleElementClass o => o -> HTMLStyleElement -toHTMLStyleElement = unsafeCastGObject . toGObject - -instance HTMLStyleElementClass HTMLStyleElement -instance HTMLElementClass HTMLStyleElement -instance ElementClass HTMLStyleElement -instance NodeClass HTMLStyleElement -instance GObjectClass HTMLStyleElement where - toGObject = GObject . castForeignPtr . unHTMLStyleElement - unsafeCastGObject = HTMLStyleElement . castForeignPtr . unGObject - -castToHTMLStyleElement :: GObjectClass obj => obj -> HTMLStyleElement -castToHTMLStyleElement = castTo gTypeHTMLStyleElement "HTMLStyleElement" - -gTypeHTMLStyleElement :: GType -gTypeHTMLStyleElement = - {# call fun unsafe webkit_dom_html_style_element_get_type #} - --- **************************************************** HTMLTableCaptionElement - -{#pointer *WebKitDOMHTMLTableCaptionElement as HTMLTableCaptionElement foreign newtype #} deriving (Eq,Ord) - -mkHTMLTableCaptionElement = (HTMLTableCaptionElement, objectUnrefFromMainloop) -unHTMLTableCaptionElement (HTMLTableCaptionElement o) = o - -class HTMLElementClass o => HTMLTableCaptionElementClass o -toHTMLTableCaptionElement :: HTMLTableCaptionElementClass o => o -> HTMLTableCaptionElement -toHTMLTableCaptionElement = unsafeCastGObject . toGObject - -instance HTMLTableCaptionElementClass HTMLTableCaptionElement -instance HTMLElementClass HTMLTableCaptionElement -instance ElementClass HTMLTableCaptionElement -instance NodeClass HTMLTableCaptionElement -instance GObjectClass HTMLTableCaptionElement where - toGObject = GObject . castForeignPtr . unHTMLTableCaptionElement - unsafeCastGObject = HTMLTableCaptionElement . castForeignPtr . unGObject - -castToHTMLTableCaptionElement :: GObjectClass obj => obj -> HTMLTableCaptionElement -castToHTMLTableCaptionElement = castTo gTypeHTMLTableCaptionElement "HTMLTableCaptionElement" - -gTypeHTMLTableCaptionElement :: GType -gTypeHTMLTableCaptionElement = - {# call fun unsafe webkit_dom_html_table_caption_element_get_type #} - --- ******************************************************* HTMLTableCellElement - -{#pointer *WebKitDOMHTMLTableCellElement as HTMLTableCellElement foreign newtype #} deriving (Eq,Ord) - -mkHTMLTableCellElement = (HTMLTableCellElement, objectUnrefFromMainloop) -unHTMLTableCellElement (HTMLTableCellElement o) = o - -class HTMLElementClass o => HTMLTableCellElementClass o -toHTMLTableCellElement :: HTMLTableCellElementClass o => o -> HTMLTableCellElement -toHTMLTableCellElement = unsafeCastGObject . toGObject - -instance HTMLTableCellElementClass HTMLTableCellElement -instance HTMLElementClass HTMLTableCellElement -instance ElementClass HTMLTableCellElement -instance NodeClass HTMLTableCellElement -instance GObjectClass HTMLTableCellElement where - toGObject = GObject . castForeignPtr . unHTMLTableCellElement - unsafeCastGObject = HTMLTableCellElement . castForeignPtr . unGObject - -castToHTMLTableCellElement :: GObjectClass obj => obj -> HTMLTableCellElement -castToHTMLTableCellElement = castTo gTypeHTMLTableCellElement "HTMLTableCellElement" - -gTypeHTMLTableCellElement :: GType -gTypeHTMLTableCellElement = - {# call fun unsafe webkit_dom_html_table_cell_element_get_type #} - --- ******************************************************** HTMLTableColElement - -{#pointer *WebKitDOMHTMLTableColElement as HTMLTableColElement foreign newtype #} deriving (Eq,Ord) - -mkHTMLTableColElement = (HTMLTableColElement, objectUnrefFromMainloop) -unHTMLTableColElement (HTMLTableColElement o) = o - -class HTMLElementClass o => HTMLTableColElementClass o -toHTMLTableColElement :: HTMLTableColElementClass o => o -> HTMLTableColElement -toHTMLTableColElement = unsafeCastGObject . toGObject - -instance HTMLTableColElementClass HTMLTableColElement -instance HTMLElementClass HTMLTableColElement -instance ElementClass HTMLTableColElement -instance NodeClass HTMLTableColElement -instance GObjectClass HTMLTableColElement where - toGObject = GObject . castForeignPtr . unHTMLTableColElement - unsafeCastGObject = HTMLTableColElement . castForeignPtr . unGObject - -castToHTMLTableColElement :: GObjectClass obj => obj -> HTMLTableColElement -castToHTMLTableColElement = castTo gTypeHTMLTableColElement "HTMLTableColElement" - -gTypeHTMLTableColElement :: GType -gTypeHTMLTableColElement = - {# call fun unsafe webkit_dom_html_table_col_element_get_type #} - --- *********************************************************** HTMLTableElement - -{#pointer *WebKitDOMHTMLTableElement as HTMLTableElement foreign newtype #} deriving (Eq,Ord) - -mkHTMLTableElement = (HTMLTableElement, objectUnrefFromMainloop) -unHTMLTableElement (HTMLTableElement o) = o - -class HTMLElementClass o => HTMLTableElementClass o -toHTMLTableElement :: HTMLTableElementClass o => o -> HTMLTableElement -toHTMLTableElement = unsafeCastGObject . toGObject - -instance HTMLTableElementClass HTMLTableElement -instance HTMLElementClass HTMLTableElement -instance ElementClass HTMLTableElement -instance NodeClass HTMLTableElement -instance GObjectClass HTMLTableElement where - toGObject = GObject . castForeignPtr . unHTMLTableElement - unsafeCastGObject = HTMLTableElement . castForeignPtr . unGObject - -castToHTMLTableElement :: GObjectClass obj => obj -> HTMLTableElement -castToHTMLTableElement = castTo gTypeHTMLTableElement "HTMLTableElement" - -gTypeHTMLTableElement :: GType -gTypeHTMLTableElement = - {# call fun unsafe webkit_dom_html_table_element_get_type #} - --- ******************************************************** HTMLTableRowElement - -{#pointer *WebKitDOMHTMLTableRowElement as HTMLTableRowElement foreign newtype #} deriving (Eq,Ord) - -mkHTMLTableRowElement = (HTMLTableRowElement, objectUnrefFromMainloop) -unHTMLTableRowElement (HTMLTableRowElement o) = o - -class HTMLElementClass o => HTMLTableRowElementClass o -toHTMLTableRowElement :: HTMLTableRowElementClass o => o -> HTMLTableRowElement -toHTMLTableRowElement = unsafeCastGObject . toGObject - -instance HTMLTableRowElementClass HTMLTableRowElement -instance HTMLElementClass HTMLTableRowElement -instance ElementClass HTMLTableRowElement -instance NodeClass HTMLTableRowElement -instance GObjectClass HTMLTableRowElement where - toGObject = GObject . castForeignPtr . unHTMLTableRowElement - unsafeCastGObject = HTMLTableRowElement . castForeignPtr . unGObject - -castToHTMLTableRowElement :: GObjectClass obj => obj -> HTMLTableRowElement -castToHTMLTableRowElement = castTo gTypeHTMLTableRowElement "HTMLTableRowElement" - -gTypeHTMLTableRowElement :: GType -gTypeHTMLTableRowElement = - {# call fun unsafe webkit_dom_html_table_row_element_get_type #} - --- **************************************************** HTMLTableSectionElement - -{#pointer *WebKitDOMHTMLTableSectionElement as HTMLTableSectionElement foreign newtype #} deriving (Eq,Ord) - -mkHTMLTableSectionElement = (HTMLTableSectionElement, objectUnrefFromMainloop) -unHTMLTableSectionElement (HTMLTableSectionElement o) = o - -class HTMLElementClass o => HTMLTableSectionElementClass o -toHTMLTableSectionElement :: HTMLTableSectionElementClass o => o -> HTMLTableSectionElement -toHTMLTableSectionElement = unsafeCastGObject . toGObject - -instance HTMLTableSectionElementClass HTMLTableSectionElement -instance HTMLElementClass HTMLTableSectionElement -instance ElementClass HTMLTableSectionElement -instance NodeClass HTMLTableSectionElement -instance GObjectClass HTMLTableSectionElement where - toGObject = GObject . castForeignPtr . unHTMLTableSectionElement - unsafeCastGObject = HTMLTableSectionElement . castForeignPtr . unGObject - -castToHTMLTableSectionElement :: GObjectClass obj => obj -> HTMLTableSectionElement -castToHTMLTableSectionElement = castTo gTypeHTMLTableSectionElement "HTMLTableSectionElement" - -gTypeHTMLTableSectionElement :: GType -gTypeHTMLTableSectionElement = - {# call fun unsafe webkit_dom_html_table_section_element_get_type #} - --- ******************************************************** HTMLTextAreaElement - -{#pointer *WebKitDOMHTMLTextAreaElement as HTMLTextAreaElement foreign newtype #} deriving (Eq,Ord) - -mkHTMLTextAreaElement = (HTMLTextAreaElement, objectUnrefFromMainloop) -unHTMLTextAreaElement (HTMLTextAreaElement o) = o - -class HTMLElementClass o => HTMLTextAreaElementClass o -toHTMLTextAreaElement :: HTMLTextAreaElementClass o => o -> HTMLTextAreaElement -toHTMLTextAreaElement = unsafeCastGObject . toGObject - -instance HTMLTextAreaElementClass HTMLTextAreaElement -instance HTMLElementClass HTMLTextAreaElement -instance ElementClass HTMLTextAreaElement -instance NodeClass HTMLTextAreaElement -instance GObjectClass HTMLTextAreaElement where - toGObject = GObject . castForeignPtr . unHTMLTextAreaElement - unsafeCastGObject = HTMLTextAreaElement . castForeignPtr . unGObject - -castToHTMLTextAreaElement :: GObjectClass obj => obj -> HTMLTextAreaElement -castToHTMLTextAreaElement = castTo gTypeHTMLTextAreaElement "HTMLTextAreaElement" - -gTypeHTMLTextAreaElement :: GType -gTypeHTMLTextAreaElement = - {# call fun unsafe webkit_dom_html_text_area_element_get_type #} - --- *********************************************************** HTMLTitleElement - -{#pointer *WebKitDOMHTMLTitleElement as HTMLTitleElement foreign newtype #} deriving (Eq,Ord) - -mkHTMLTitleElement = (HTMLTitleElement, objectUnrefFromMainloop) -unHTMLTitleElement (HTMLTitleElement o) = o - -class HTMLElementClass o => HTMLTitleElementClass o -toHTMLTitleElement :: HTMLTitleElementClass o => o -> HTMLTitleElement -toHTMLTitleElement = unsafeCastGObject . toGObject - -instance HTMLTitleElementClass HTMLTitleElement -instance HTMLElementClass HTMLTitleElement -instance ElementClass HTMLTitleElement -instance NodeClass HTMLTitleElement -instance GObjectClass HTMLTitleElement where - toGObject = GObject . castForeignPtr . unHTMLTitleElement - unsafeCastGObject = HTMLTitleElement . castForeignPtr . unGObject - -castToHTMLTitleElement :: GObjectClass obj => obj -> HTMLTitleElement -castToHTMLTitleElement = castTo gTypeHTMLTitleElement "HTMLTitleElement" - -gTypeHTMLTitleElement :: GType -gTypeHTMLTitleElement = - {# call fun unsafe webkit_dom_html_title_element_get_type #} - --- *********************************************************** HTMLUListElement - -{#pointer *WebKitDOMHTMLUListElement as HTMLUListElement foreign newtype #} deriving (Eq,Ord) - -mkHTMLUListElement = (HTMLUListElement, objectUnrefFromMainloop) -unHTMLUListElement (HTMLUListElement o) = o - -class HTMLElementClass o => HTMLUListElementClass o -toHTMLUListElement :: HTMLUListElementClass o => o -> HTMLUListElement -toHTMLUListElement = unsafeCastGObject . toGObject - -instance HTMLUListElementClass HTMLUListElement -instance HTMLElementClass HTMLUListElement -instance ElementClass HTMLUListElement -instance NodeClass HTMLUListElement -instance GObjectClass HTMLUListElement where - toGObject = GObject . castForeignPtr . unHTMLUListElement - unsafeCastGObject = HTMLUListElement . castForeignPtr . unGObject - -castToHTMLUListElement :: GObjectClass obj => obj -> HTMLUListElement -castToHTMLUListElement = castTo gTypeHTMLUListElement "HTMLUListElement" - -gTypeHTMLUListElement :: GType -gTypeHTMLUListElement = - {# call fun unsafe webkit_dom_htmlu_list_element_get_type #} - --- ************************************************************ EntityReference - -{#pointer *WebKitDOMEntityReference as EntityReference foreign newtype #} deriving (Eq,Ord) - -mkEntityReference = (EntityReference, objectUnrefFromMainloop) -unEntityReference (EntityReference o) = o - -class NodeClass o => EntityReferenceClass o -toEntityReference :: EntityReferenceClass o => o -> EntityReference -toEntityReference = unsafeCastGObject . toGObject - -instance EntityReferenceClass EntityReference -instance NodeClass EntityReference -instance GObjectClass EntityReference where - toGObject = GObject . castForeignPtr . unEntityReference - unsafeCastGObject = EntityReference . castForeignPtr . unGObject - -castToEntityReference :: GObjectClass obj => obj -> EntityReference -castToEntityReference = castTo gTypeEntityReference "EntityReference" - -gTypeEntityReference :: GType -gTypeEntityReference = - {# call fun unsafe webkit_dom_entity_reference_get_type #} - --- ****************************************************** ProcessingInstruction - -{#pointer *WebKitDOMProcessingInstruction as ProcessingInstruction foreign newtype #} deriving (Eq,Ord) - -mkProcessingInstruction = (ProcessingInstruction, objectUnrefFromMainloop) -unProcessingInstruction (ProcessingInstruction o) = o - -class NodeClass o => ProcessingInstructionClass o -toProcessingInstruction :: ProcessingInstructionClass o => o -> ProcessingInstruction -toProcessingInstruction = unsafeCastGObject . toGObject - -instance ProcessingInstructionClass ProcessingInstruction -instance NodeClass ProcessingInstruction -instance GObjectClass ProcessingInstruction where - toGObject = GObject . castForeignPtr . unProcessingInstruction - unsafeCastGObject = ProcessingInstruction . castForeignPtr . unGObject - -castToProcessingInstruction :: GObjectClass obj => obj -> ProcessingInstruction -castToProcessingInstruction = castTo gTypeProcessingInstruction "ProcessingInstruction" - -gTypeProcessingInstruction :: GType -gTypeProcessingInstruction = - {# call fun unsafe webkit_dom_processing_instruction_get_type #} - --- ***************************************************************** NodeFilter - -{#pointer *WebKitDOMNodeFilter as NodeFilter foreign newtype #} deriving (Eq,Ord) - -mkNodeFilter = (NodeFilter, objectUnrefFromMainloop) -unNodeFilter (NodeFilter o) = o - -class GObjectClass o => NodeFilterClass o -toNodeFilter :: NodeFilterClass o => o -> NodeFilter -toNodeFilter = unsafeCastGObject . toGObject - -instance NodeFilterClass NodeFilter -instance GObjectClass NodeFilter where - toGObject = GObject . castForeignPtr . unNodeFilter - unsafeCastGObject = NodeFilter . castForeignPtr . unGObject - -castToNodeFilter :: GObjectClass obj => obj -> NodeFilter -castToNodeFilter = castTo gTypeNodeFilter "NodeFilter" - -gTypeNodeFilter :: GType -gTypeNodeFilter = - {# call fun unsafe webkit_dom_node_filter_get_type #} - --- *************************************************************** NodeIterator - -{#pointer *WebKitDOMNodeIterator as NodeIterator foreign newtype #} deriving (Eq,Ord) - -mkNodeIterator = (NodeIterator, objectUnrefFromMainloop) -unNodeIterator (NodeIterator o) = o - -class GObjectClass o => NodeIteratorClass o -toNodeIterator :: NodeIteratorClass o => o -> NodeIterator -toNodeIterator = unsafeCastGObject . toGObject - -instance NodeIteratorClass NodeIterator -instance GObjectClass NodeIterator where - toGObject = GObject . castForeignPtr . unNodeIterator - unsafeCastGObject = NodeIterator . castForeignPtr . unGObject - -castToNodeIterator :: GObjectClass obj => obj -> NodeIterator -castToNodeIterator = castTo gTypeNodeIterator "NodeIterator" - -gTypeNodeIterator :: GType -gTypeNodeIterator = - {# call fun unsafe webkit_dom_node_iterator_get_type #} - --- ******************************************************************* NodeList - -{#pointer *WebKitDOMNodeList as NodeList foreign newtype #} deriving (Eq,Ord) - -mkNodeList = (NodeList, objectUnrefFromMainloop) -unNodeList (NodeList o) = o - -class GObjectClass o => NodeListClass o -toNodeList :: NodeListClass o => o -> NodeList -toNodeList = unsafeCastGObject . toGObject - -instance NodeListClass NodeList -instance GObjectClass NodeList where - toGObject = GObject . castForeignPtr . unNodeList - unsafeCastGObject = NodeList . castForeignPtr . unGObject - -castToNodeList :: GObjectClass obj => obj -> NodeList -castToNodeList = castTo gTypeNodeList "NodeList" - -gTypeNodeList :: GType -gTypeNodeList = - {# call fun unsafe webkit_dom_node_list_get_type #} - --- ******************************************************************* DOMRange - -{#pointer *WebKitDOMRange as DOMRange foreign newtype #} deriving (Eq,Ord) - -mkDOMRange = (DOMRange, objectUnrefFromMainloop) -unDOMRange (DOMRange o) = o - -class GObjectClass o => DOMRangeClass o -toDOMRange :: DOMRangeClass o => o -> DOMRange -toDOMRange = unsafeCastGObject . toGObject - -instance DOMRangeClass DOMRange -instance GObjectClass DOMRange where - toGObject = GObject . castForeignPtr . unDOMRange - unsafeCastGObject = DOMRange . castForeignPtr . unGObject - -castToDOMRange :: GObjectClass obj => obj -> DOMRange -castToDOMRange = castTo gTypeDOMRange "DOMRange" - -gTypeDOMRange :: GType -gTypeDOMRange = - {# call fun unsafe webkit_dom_range_get_type #} - --- ****************************************************************** DOMScreen - -{#pointer *WebKitDOMScreen as DOMScreen foreign newtype #} deriving (Eq,Ord) - -mkDOMScreen = (DOMScreen, objectUnrefFromMainloop) -unDOMScreen (DOMScreen o) = o - -class GObjectClass o => DOMScreenClass o -toDOMScreen :: DOMScreenClass o => o -> DOMScreen -toDOMScreen = unsafeCastGObject . toGObject - -instance DOMScreenClass DOMScreen -instance GObjectClass DOMScreen where - toGObject = GObject . castForeignPtr . unDOMScreen - unsafeCastGObject = DOMScreen . castForeignPtr . unGObject - -castToDOMScreen :: GObjectClass obj => obj -> DOMScreen -castToDOMScreen = castTo gTypeDOMScreen "DOMScreen" - -gTypeDOMScreen :: GType -gTypeDOMScreen = - {# call fun unsafe webkit_dom_screen_get_type #} - --- ******************************************************************** Storage - -{#pointer *WebKitDOMStorage as Storage foreign newtype #} deriving (Eq,Ord) - -mkStorage = (Storage, objectUnrefFromMainloop) -unStorage (Storage o) = o - -class GObjectClass o => StorageClass o -toStorage :: StorageClass o => o -> Storage -toStorage = unsafeCastGObject . toGObject - -instance StorageClass Storage -instance GObjectClass Storage where - toGObject = GObject . castForeignPtr . unStorage - unsafeCastGObject = Storage . castForeignPtr . unGObject - -castToStorage :: GObjectClass obj => obj -> Storage -castToStorage = castTo gTypeStorage "Storage" - -gTypeStorage :: GType -gTypeStorage = - {# call fun unsafe webkit_dom_storage_get_type #} - --- **************************************************************** StorageInfo - -{#pointer *WebKitDOMStorageInfo as StorageInfo foreign newtype #} deriving (Eq,Ord) - -mkStorageInfo = (StorageInfo, objectUnrefFromMainloop) -unStorageInfo (StorageInfo o) = o - -class GObjectClass o => StorageInfoClass o -toStorageInfo :: StorageInfoClass o => o -> StorageInfo -toStorageInfo = unsafeCastGObject . toGObject - -instance StorageInfoClass StorageInfo -instance GObjectClass StorageInfo where - toGObject = GObject . castForeignPtr . unStorageInfo - unsafeCastGObject = StorageInfo . castForeignPtr . unGObject - -castToStorageInfo :: GObjectClass obj => obj -> StorageInfo -castToStorageInfo = castTo gTypeStorageInfo "StorageInfo" - -gTypeStorageInfo :: GType -gTypeStorageInfo = - {# call fun unsafe webkit_dom_storage_info_get_type #} - --- ***************************************************************** StyleMedia - -{#pointer *WebKitDOMStyleMedia as StyleMedia foreign newtype #} deriving (Eq,Ord) - -mkStyleMedia = (StyleMedia, objectUnrefFromMainloop) -unStyleMedia (StyleMedia o) = o - -class GObjectClass o => StyleMediaClass o -toStyleMedia :: StyleMediaClass o => o -> StyleMedia -toStyleMedia = unsafeCastGObject . toGObject - -instance StyleMediaClass StyleMedia -instance GObjectClass StyleMedia where - toGObject = GObject . castForeignPtr . unStyleMedia - unsafeCastGObject = StyleMedia . castForeignPtr . unGObject - -castToStyleMedia :: GObjectClass obj => obj -> StyleMedia -castToStyleMedia = castTo gTypeStyleMedia "StyleMedia" - -gTypeStyleMedia :: GType -gTypeStyleMedia = - {# call fun unsafe webkit_dom_style_media_get_type #} - --- ***************************************************************** StyleSheet - -{#pointer *WebKitDOMStyleSheet as StyleSheet foreign newtype #} deriving (Eq,Ord) - -mkStyleSheet = (StyleSheet, objectUnrefFromMainloop) -unStyleSheet (StyleSheet o) = o - -class GObjectClass o => StyleSheetClass o -toStyleSheet :: StyleSheetClass o => o -> StyleSheet -toStyleSheet = unsafeCastGObject . toGObject - -instance StyleSheetClass StyleSheet -instance GObjectClass StyleSheet where - toGObject = GObject . castForeignPtr . unStyleSheet - unsafeCastGObject = StyleSheet . castForeignPtr . unGObject - -castToStyleSheet :: GObjectClass obj => obj -> StyleSheet -castToStyleSheet = castTo gTypeStyleSheet "StyleSheet" - -gTypeStyleSheet :: GType -gTypeStyleSheet = - {# call fun unsafe webkit_dom_style_sheet_get_type #} - --- ************************************************************** CSSStyleSheet - -{#pointer *WebKitDOMCSSStyleSheet as CSSStyleSheet foreign newtype #} deriving (Eq,Ord) - -mkCSSStyleSheet = (CSSStyleSheet, objectUnrefFromMainloop) -unCSSStyleSheet (CSSStyleSheet o) = o - -class StyleSheetClass o => CSSStyleSheetClass o -toCSSStyleSheet :: CSSStyleSheetClass o => o -> CSSStyleSheet -toCSSStyleSheet = unsafeCastGObject . toGObject - -instance CSSStyleSheetClass CSSStyleSheet -instance StyleSheetClass CSSStyleSheet -instance GObjectClass CSSStyleSheet where - toGObject = GObject . castForeignPtr . unCSSStyleSheet - unsafeCastGObject = CSSStyleSheet . castForeignPtr . unGObject - -castToCSSStyleSheet :: GObjectClass obj => obj -> CSSStyleSheet -castToCSSStyleSheet = castTo gTypeCSSStyleSheet "CSSStyleSheet" - -gTypeCSSStyleSheet :: GType -gTypeCSSStyleSheet = - {# call fun unsafe webkit_dom_css_style_sheet_get_type #} - --- ************************************************************* StyleSheetList - -{#pointer *WebKitDOMStyleSheetList as StyleSheetList foreign newtype #} deriving (Eq,Ord) - -mkStyleSheetList = (StyleSheetList, objectUnrefFromMainloop) -unStyleSheetList (StyleSheetList o) = o - -class GObjectClass o => StyleSheetListClass o -toStyleSheetList :: StyleSheetListClass o => o -> StyleSheetList -toStyleSheetList = unsafeCastGObject . toGObject - -instance StyleSheetListClass StyleSheetList -instance GObjectClass StyleSheetList where - toGObject = GObject . castForeignPtr . unStyleSheetList - unsafeCastGObject = StyleSheetList . castForeignPtr . unGObject - -castToStyleSheetList :: GObjectClass obj => obj -> StyleSheetList -castToStyleSheetList = castTo gTypeStyleSheetList "StyleSheetList" - -gTypeStyleSheetList :: GType -gTypeStyleSheetList = - {# call fun unsafe webkit_dom_style_sheet_list_get_type #} - --- ***************************************************************** TimeRanges - -{#pointer *WebKitDOMTimeRanges as TimeRanges foreign newtype #} deriving (Eq,Ord) - -mkTimeRanges = (TimeRanges, objectUnrefFromMainloop) -unTimeRanges (TimeRanges o) = o - -class GObjectClass o => TimeRangesClass o -toTimeRanges :: TimeRangesClass o => o -> TimeRanges -toTimeRanges = unsafeCastGObject . toGObject - -instance TimeRangesClass TimeRanges -instance GObjectClass TimeRanges where - toGObject = GObject . castForeignPtr . unTimeRanges - unsafeCastGObject = TimeRanges . castForeignPtr . unGObject - -castToTimeRanges :: GObjectClass obj => obj -> TimeRanges -castToTimeRanges = castTo gTypeTimeRanges "TimeRanges" - -gTypeTimeRanges :: GType -gTypeTimeRanges = - {# call fun unsafe webkit_dom_time_ranges_get_type #} - --- ***************************************************************** TreeWalker - -{#pointer *WebKitDOMTreeWalker as TreeWalker foreign newtype #} deriving (Eq,Ord) - -mkTreeWalker = (TreeWalker, objectUnrefFromMainloop) -unTreeWalker (TreeWalker o) = o - -class GObjectClass o => TreeWalkerClass o -toTreeWalker :: TreeWalkerClass o => o -> TreeWalker -toTreeWalker = unsafeCastGObject . toGObject - -instance TreeWalkerClass TreeWalker -instance GObjectClass TreeWalker where - toGObject = GObject . castForeignPtr . unTreeWalker - unsafeCastGObject = TreeWalker . castForeignPtr . unGObject - -castToTreeWalker :: GObjectClass obj => obj -> TreeWalker -castToTreeWalker = castTo gTypeTreeWalker "TreeWalker" - -gTypeTreeWalker :: GType -gTypeTreeWalker = - {# call fun unsafe webkit_dom_tree_walker_get_type #} - --- ************************************************************** ValidityState - -{#pointer *WebKitDOMValidityState as ValidityState foreign newtype #} deriving (Eq,Ord) - -mkValidityState = (ValidityState, objectUnrefFromMainloop) -unValidityState (ValidityState o) = o - -class GObjectClass o => ValidityStateClass o -toValidityState :: ValidityStateClass o => o -> ValidityState -toValidityState = unsafeCastGObject . toGObject - -instance ValidityStateClass ValidityState -instance GObjectClass ValidityState where - toGObject = GObject . castForeignPtr . unValidityState - unsafeCastGObject = ValidityState . castForeignPtr . unGObject - -castToValidityState :: GObjectClass obj => obj -> ValidityState -castToValidityState = castTo gTypeValidityState "ValidityState" - -gTypeValidityState :: GType -gTypeValidityState = - {# call fun unsafe webkit_dom_validity_state_get_type #} - --- ************************************************************ WebKitNamedFlow - -{#pointer *WebKitDOMWebKitNamedFlow as WebKitNamedFlow foreign newtype #} deriving (Eq,Ord) - -mkWebKitNamedFlow = (WebKitNamedFlow, objectUnrefFromMainloop) -unWebKitNamedFlow (WebKitNamedFlow o) = o - -class GObjectClass o => WebKitNamedFlowClass o -toWebKitNamedFlow :: WebKitNamedFlowClass o => o -> WebKitNamedFlow -toWebKitNamedFlow = unsafeCastGObject . toGObject - -instance WebKitNamedFlowClass WebKitNamedFlow -instance GObjectClass WebKitNamedFlow where - toGObject = GObject . castForeignPtr . unWebKitNamedFlow - unsafeCastGObject = WebKitNamedFlow . castForeignPtr . unGObject - -castToWebKitNamedFlow :: GObjectClass obj => obj -> WebKitNamedFlow -castToWebKitNamedFlow = castTo gTypeWebKitNamedFlow "WebKitNamedFlow" - -gTypeWebKitNamedFlow :: GType -gTypeWebKitNamedFlow = - {# call fun unsafe webkit_dom_webkit_named_flow_get_type #} +{-# OPTIONS_GHC -fno-warn-unused-imports #-} +-- -*-haskell-*- +-- -------------------- automatically generated file - do not edit ---------- +-- Object hierarchy for the GIMP Toolkit (GTK) Binding for Haskell +-- +-- Author : Axel Simon +-- +-- Copyright (C) 2001-2005 Axel Simon +-- +-- This library is free software; you can redistribute it and/or +-- modify it under the terms of the GNU Lesser General Public +-- License as published by the Free Software Foundation; either +-- version 2.1 of the License, or (at your option) any later version. +-- +-- This library is distributed in the hope that it will be useful, +-- but WITHOUT ANY WARRANTY; without even the implied warranty of +-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +-- Lesser General Public License for more details. +-- +-- #hide + +-- | +-- Maintainer : gtk2hs-users@lists.sourceforge.net +-- Stability : provisional +-- Portability : portable (depends on GHC) +-- +-- This file reflects the Gtk+ object hierarchy in terms of Haskell classes. +-- +-- Note: the mk... functions were originally meant to simply be an alias +-- for the constructor. However, in order to communicate the destructor +-- of an object to objectNew, the mk... functions are now a tuple containing +-- Haskell constructor and the destructor function pointer. This hack avoids +-- changing all modules that simply pass mk... to objectNew. +-- +module Graphics.UI.Gtk.WebKit.Types ( + + module Graphics.UI.Gtk.WebKit.GtkInternals, + WebView(WebView), WebViewClass, + toWebView, + mkWebView, unWebView, + castToWebView, gTypeWebView, + WebFrame(WebFrame), WebFrameClass, + toWebFrame, + mkWebFrame, unWebFrame, + castToWebFrame, gTypeWebFrame, + WebSettings(WebSettings), WebSettingsClass, + toWebSettings, + mkWebSettings, unWebSettings, + castToWebSettings, gTypeWebSettings, + NetworkRequest(NetworkRequest), NetworkRequestClass, + toNetworkRequest, + mkNetworkRequest, unNetworkRequest, + castToNetworkRequest, gTypeNetworkRequest, + NetworkResponse(NetworkResponse), NetworkResponseClass, + toNetworkResponse, + mkNetworkResponse, unNetworkResponse, + castToNetworkResponse, gTypeNetworkResponse, + Download(Download), DownloadClass, + toDownload, + mkDownload, unDownload, + castToDownload, gTypeDownload, + WebBackForwardList(WebBackForwardList), WebBackForwardListClass, + toWebBackForwardList, + mkWebBackForwardList, unWebBackForwardList, + castToWebBackForwardList, gTypeWebBackForwardList, + WebHistoryItem(WebHistoryItem), WebHistoryItemClass, + toWebHistoryItem, + mkWebHistoryItem, unWebHistoryItem, + castToWebHistoryItem, gTypeWebHistoryItem, + WebInspector(WebInspector), WebInspectorClass, + toWebInspector, + mkWebInspector, unWebInspector, + castToWebInspector, gTypeWebInspector, + HitTestResult(HitTestResult), HitTestResultClass, + toHitTestResult, + mkHitTestResult, unHitTestResult, + castToHitTestResult, gTypeHitTestResult, + SecurityOrigin(SecurityOrigin), SecurityOriginClass, + toSecurityOrigin, + mkSecurityOrigin, unSecurityOrigin, + castToSecurityOrigin, gTypeSecurityOrigin, + SoupAuthDialog(SoupAuthDialog), SoupAuthDialogClass, + toSoupAuthDialog, + mkSoupAuthDialog, unSoupAuthDialog, + castToSoupAuthDialog, gTypeSoupAuthDialog, + WebDatabase(WebDatabase), WebDatabaseClass, + toWebDatabase, + mkWebDatabase, unWebDatabase, + castToWebDatabase, gTypeWebDatabase, + WebDataSource(WebDataSource), WebDataSourceClass, + toWebDataSource, + mkWebDataSource, unWebDataSource, + castToWebDataSource, gTypeWebDataSource, + WebNavigationAction(WebNavigationAction), WebNavigationActionClass, + toWebNavigationAction, + mkWebNavigationAction, unWebNavigationAction, + castToWebNavigationAction, gTypeWebNavigationAction, + WebPolicyDecision(WebPolicyDecision), WebPolicyDecisionClass, + toWebPolicyDecision, + mkWebPolicyDecision, unWebPolicyDecision, + castToWebPolicyDecision, gTypeWebPolicyDecision, + WebResource(WebResource), WebResourceClass, + toWebResource, + mkWebResource, unWebResource, + castToWebResource, gTypeWebResource, + WebWindowFeatures(WebWindowFeatures), WebWindowFeaturesClass, + toWebWindowFeatures, + mkWebWindowFeatures, unWebWindowFeatures, + castToWebWindowFeatures, gTypeWebWindowFeatures, + GeolocationPolicyDecision(GeolocationPolicyDecision), GeolocationPolicyDecisionClass, + toGeolocationPolicyDecision, + mkGeolocationPolicyDecision, unGeolocationPolicyDecision, + castToGeolocationPolicyDecision, gTypeGeolocationPolicyDecision, + AudioTrack(AudioTrack), AudioTrackClass, + toAudioTrack, + mkAudioTrack, unAudioTrack, + castToAudioTrack, gTypeAudioTrack, + BarProp(BarProp), BarPropClass, + toBarProp, + mkBarProp, unBarProp, + castToBarProp, gTypeBarProp, + Blob(Blob), BlobClass, + toBlob, + mkBlob, unBlob, + castToBlob, gTypeBlob, + File(File), FileClass, + toFile, + mkFile, unFile, + castToFile, gTypeFile, + CSS(CSS), CSSClass, + toCSS, + mkCSS, unCSS, + castToCSS, gTypeCSS, + CSSRule(CSSRule), CSSRuleClass, + toCSSRule, + mkCSSRule, unCSSRule, + castToCSSRule, gTypeCSSRule, + CSSRuleList(CSSRuleList), CSSRuleListClass, + toCSSRuleList, + mkCSSRuleList, unCSSRuleList, + castToCSSRuleList, gTypeCSSRuleList, + CSSStyleDeclaration(CSSStyleDeclaration), CSSStyleDeclarationClass, + toCSSStyleDeclaration, + mkCSSStyleDeclaration, unCSSStyleDeclaration, + castToCSSStyleDeclaration, gTypeCSSStyleDeclaration, + CSSValue(CSSValue), CSSValueClass, + toCSSValue, + mkCSSValue, unCSSValue, + castToCSSValue, gTypeCSSValue, + DOMImplementation(DOMImplementation), DOMImplementationClass, + toDOMImplementation, + mkDOMImplementation, unDOMImplementation, + castToDOMImplementation, gTypeDOMImplementation, + DOMNamedFlowCollection(DOMNamedFlowCollection), DOMNamedFlowCollectionClass, + toDOMNamedFlowCollection, + mkDOMNamedFlowCollection, unDOMNamedFlowCollection, + castToDOMNamedFlowCollection, gTypeDOMNamedFlowCollection, + DOMStringList(DOMStringList), DOMStringListClass, + toDOMStringList, + mkDOMStringList, unDOMStringList, + castToDOMStringList, gTypeDOMStringList, + DOMTokenList(DOMTokenList), DOMTokenListClass, + toDOMTokenList, + mkDOMTokenList, unDOMTokenList, + castToDOMTokenList, gTypeDOMTokenList, + DOMSettableTokenList(DOMSettableTokenList), DOMSettableTokenListClass, + toDOMSettableTokenList, + mkDOMSettableTokenList, unDOMSettableTokenList, + castToDOMSettableTokenList, gTypeDOMSettableTokenList, + Event(Event), EventClass, + toEvent, + mkEvent, unEvent, + castToEvent, gTypeEvent, + UIEvent(UIEvent), UIEventClass, + toUIEvent, + mkUIEvent, unUIEvent, + castToUIEvent, gTypeUIEvent, + KeyboardEvent(KeyboardEvent), KeyboardEventClass, + toKeyboardEvent, + mkKeyboardEvent, unKeyboardEvent, + castToKeyboardEvent, gTypeKeyboardEvent, + MouseEvent(MouseEvent), MouseEventClass, + toMouseEvent, + mkMouseEvent, unMouseEvent, + castToMouseEvent, gTypeMouseEvent, + WheelEvent(WheelEvent), WheelEventClass, + toWheelEvent, + mkWheelEvent, unWheelEvent, + castToWheelEvent, gTypeWheelEvent, + EventTarget(EventTarget), EventTargetClass, + toEventTarget, + mkEventTarget, unEventTarget, + castToEventTarget, gTypeEventTarget, + ApplicationCache(ApplicationCache), ApplicationCacheClass, + toApplicationCache, + mkApplicationCache, unApplicationCache, + castToApplicationCache, gTypeApplicationCache, + AudioTrackList(AudioTrackList), AudioTrackListClass, + toAudioTrackList, + mkAudioTrackList, unAudioTrackList, + castToAudioTrackList, gTypeAudioTrackList, + BatteryManager(BatteryManager), BatteryManagerClass, + toBatteryManager, + mkBatteryManager, unBatteryManager, + castToBatteryManager, gTypeBatteryManager, + MessagePort(MessagePort), MessagePortClass, + toMessagePort, + mkMessagePort, unMessagePort, + castToMessagePort, gTypeMessagePort, + Node(Node), NodeClass, + toNode, + mkNode, unNode, + castToNode, gTypeNode, + Attr(Attr), AttrClass, + toAttr, + mkAttr, unAttr, + castToAttr, gTypeAttr, + CharacterData(CharacterData), CharacterDataClass, + toCharacterData, + mkCharacterData, unCharacterData, + castToCharacterData, gTypeCharacterData, + Comment(Comment), CommentClass, + toComment, + mkComment, unComment, + castToComment, gTypeComment, + ProcessingInstruction(ProcessingInstruction), ProcessingInstructionClass, + toProcessingInstruction, + mkProcessingInstruction, unProcessingInstruction, + castToProcessingInstruction, gTypeProcessingInstruction, + Text(Text), TextClass, + toText, + mkText, unText, + castToText, gTypeText, + CDATASection(CDATASection), CDATASectionClass, + toCDATASection, + mkCDATASection, unCDATASection, + castToCDATASection, gTypeCDATASection, + Document(Document), DocumentClass, + toDocument, + mkDocument, unDocument, + castToDocument, gTypeDocument, + HTMLDocument(HTMLDocument), HTMLDocumentClass, + toHTMLDocument, + mkHTMLDocument, unHTMLDocument, + castToHTMLDocument, gTypeHTMLDocument, + DocumentFragment(DocumentFragment), DocumentFragmentClass, + toDocumentFragment, + mkDocumentFragment, unDocumentFragment, + castToDocumentFragment, gTypeDocumentFragment, + DocumentType(DocumentType), DocumentTypeClass, + toDocumentType, + mkDocumentType, unDocumentType, + castToDocumentType, gTypeDocumentType, + Element(Element), ElementClass, + toElement, + mkElement, unElement, + castToElement, gTypeElement, + HTMLElement(HTMLElement), HTMLElementClass, + toHTMLElement, + mkHTMLElement, unHTMLElement, + castToHTMLElement, gTypeHTMLElement, + HTMLAnchorElement(HTMLAnchorElement), HTMLAnchorElementClass, + toHTMLAnchorElement, + mkHTMLAnchorElement, unHTMLAnchorElement, + castToHTMLAnchorElement, gTypeHTMLAnchorElement, + HTMLAppletElement(HTMLAppletElement), HTMLAppletElementClass, + toHTMLAppletElement, + mkHTMLAppletElement, unHTMLAppletElement, + castToHTMLAppletElement, gTypeHTMLAppletElement, + HTMLAreaElement(HTMLAreaElement), HTMLAreaElementClass, + toHTMLAreaElement, + mkHTMLAreaElement, unHTMLAreaElement, + castToHTMLAreaElement, gTypeHTMLAreaElement, + HTMLBRElement(HTMLBRElement), HTMLBRElementClass, + toHTMLBRElement, + mkHTMLBRElement, unHTMLBRElement, + castToHTMLBRElement, gTypeHTMLBRElement, + HTMLBaseElement(HTMLBaseElement), HTMLBaseElementClass, + toHTMLBaseElement, + mkHTMLBaseElement, unHTMLBaseElement, + castToHTMLBaseElement, gTypeHTMLBaseElement, + HTMLBaseFontElement(HTMLBaseFontElement), HTMLBaseFontElementClass, + toHTMLBaseFontElement, + mkHTMLBaseFontElement, unHTMLBaseFontElement, + castToHTMLBaseFontElement, gTypeHTMLBaseFontElement, + HTMLBodyElement(HTMLBodyElement), HTMLBodyElementClass, + toHTMLBodyElement, + mkHTMLBodyElement, unHTMLBodyElement, + castToHTMLBodyElement, gTypeHTMLBodyElement, + HTMLButtonElement(HTMLButtonElement), HTMLButtonElementClass, + toHTMLButtonElement, + mkHTMLButtonElement, unHTMLButtonElement, + castToHTMLButtonElement, gTypeHTMLButtonElement, + HTMLCanvasElement(HTMLCanvasElement), HTMLCanvasElementClass, + toHTMLCanvasElement, + mkHTMLCanvasElement, unHTMLCanvasElement, + castToHTMLCanvasElement, gTypeHTMLCanvasElement, + HTMLDListElement(HTMLDListElement), HTMLDListElementClass, + toHTMLDListElement, + mkHTMLDListElement, unHTMLDListElement, + castToHTMLDListElement, gTypeHTMLDListElement, + HTMLDetailsElement(HTMLDetailsElement), HTMLDetailsElementClass, + toHTMLDetailsElement, + mkHTMLDetailsElement, unHTMLDetailsElement, + castToHTMLDetailsElement, gTypeHTMLDetailsElement, + HTMLDirectoryElement(HTMLDirectoryElement), HTMLDirectoryElementClass, + toHTMLDirectoryElement, + mkHTMLDirectoryElement, unHTMLDirectoryElement, + castToHTMLDirectoryElement, gTypeHTMLDirectoryElement, + HTMLDivElement(HTMLDivElement), HTMLDivElementClass, + toHTMLDivElement, + mkHTMLDivElement, unHTMLDivElement, + castToHTMLDivElement, gTypeHTMLDivElement, + HTMLEmbedElement(HTMLEmbedElement), HTMLEmbedElementClass, + toHTMLEmbedElement, + mkHTMLEmbedElement, unHTMLEmbedElement, + castToHTMLEmbedElement, gTypeHTMLEmbedElement, + HTMLFieldSetElement(HTMLFieldSetElement), HTMLFieldSetElementClass, + toHTMLFieldSetElement, + mkHTMLFieldSetElement, unHTMLFieldSetElement, + castToHTMLFieldSetElement, gTypeHTMLFieldSetElement, + HTMLFontElement(HTMLFontElement), HTMLFontElementClass, + toHTMLFontElement, + mkHTMLFontElement, unHTMLFontElement, + castToHTMLFontElement, gTypeHTMLFontElement, + HTMLFormElement(HTMLFormElement), HTMLFormElementClass, + toHTMLFormElement, + mkHTMLFormElement, unHTMLFormElement, + castToHTMLFormElement, gTypeHTMLFormElement, + HTMLFrameElement(HTMLFrameElement), HTMLFrameElementClass, + toHTMLFrameElement, + mkHTMLFrameElement, unHTMLFrameElement, + castToHTMLFrameElement, gTypeHTMLFrameElement, + HTMLFrameSetElement(HTMLFrameSetElement), HTMLFrameSetElementClass, + toHTMLFrameSetElement, + mkHTMLFrameSetElement, unHTMLFrameSetElement, + castToHTMLFrameSetElement, gTypeHTMLFrameSetElement, + HTMLHRElement(HTMLHRElement), HTMLHRElementClass, + toHTMLHRElement, + mkHTMLHRElement, unHTMLHRElement, + castToHTMLHRElement, gTypeHTMLHRElement, + HTMLHeadElement(HTMLHeadElement), HTMLHeadElementClass, + toHTMLHeadElement, + mkHTMLHeadElement, unHTMLHeadElement, + castToHTMLHeadElement, gTypeHTMLHeadElement, + HTMLHeadingElement(HTMLHeadingElement), HTMLHeadingElementClass, + toHTMLHeadingElement, + mkHTMLHeadingElement, unHTMLHeadingElement, + castToHTMLHeadingElement, gTypeHTMLHeadingElement, + HTMLHtmlElement(HTMLHtmlElement), HTMLHtmlElementClass, + toHTMLHtmlElement, + mkHTMLHtmlElement, unHTMLHtmlElement, + castToHTMLHtmlElement, gTypeHTMLHtmlElement, + HTMLIFrameElement(HTMLIFrameElement), HTMLIFrameElementClass, + toHTMLIFrameElement, + mkHTMLIFrameElement, unHTMLIFrameElement, + castToHTMLIFrameElement, gTypeHTMLIFrameElement, + HTMLImageElement(HTMLImageElement), HTMLImageElementClass, + toHTMLImageElement, + mkHTMLImageElement, unHTMLImageElement, + castToHTMLImageElement, gTypeHTMLImageElement, + HTMLInputElement(HTMLInputElement), HTMLInputElementClass, + toHTMLInputElement, + mkHTMLInputElement, unHTMLInputElement, + castToHTMLInputElement, gTypeHTMLInputElement, + HTMLKeygenElement(HTMLKeygenElement), HTMLKeygenElementClass, + toHTMLKeygenElement, + mkHTMLKeygenElement, unHTMLKeygenElement, + castToHTMLKeygenElement, gTypeHTMLKeygenElement, + HTMLLIElement(HTMLLIElement), HTMLLIElementClass, + toHTMLLIElement, + mkHTMLLIElement, unHTMLLIElement, + castToHTMLLIElement, gTypeHTMLLIElement, + HTMLLabelElement(HTMLLabelElement), HTMLLabelElementClass, + toHTMLLabelElement, + mkHTMLLabelElement, unHTMLLabelElement, + castToHTMLLabelElement, gTypeHTMLLabelElement, + HTMLLegendElement(HTMLLegendElement), HTMLLegendElementClass, + toHTMLLegendElement, + mkHTMLLegendElement, unHTMLLegendElement, + castToHTMLLegendElement, gTypeHTMLLegendElement, + HTMLLinkElement(HTMLLinkElement), HTMLLinkElementClass, + toHTMLLinkElement, + mkHTMLLinkElement, unHTMLLinkElement, + castToHTMLLinkElement, gTypeHTMLLinkElement, + HTMLMapElement(HTMLMapElement), HTMLMapElementClass, + toHTMLMapElement, + mkHTMLMapElement, unHTMLMapElement, + castToHTMLMapElement, gTypeHTMLMapElement, + HTMLMarqueeElement(HTMLMarqueeElement), HTMLMarqueeElementClass, + toHTMLMarqueeElement, + mkHTMLMarqueeElement, unHTMLMarqueeElement, + castToHTMLMarqueeElement, gTypeHTMLMarqueeElement, + HTMLMenuElement(HTMLMenuElement), HTMLMenuElementClass, + toHTMLMenuElement, + mkHTMLMenuElement, unHTMLMenuElement, + castToHTMLMenuElement, gTypeHTMLMenuElement, + HTMLMetaElement(HTMLMetaElement), HTMLMetaElementClass, + toHTMLMetaElement, + mkHTMLMetaElement, unHTMLMetaElement, + castToHTMLMetaElement, gTypeHTMLMetaElement, + HTMLModElement(HTMLModElement), HTMLModElementClass, + toHTMLModElement, + mkHTMLModElement, unHTMLModElement, + castToHTMLModElement, gTypeHTMLModElement, + HTMLOListElement(HTMLOListElement), HTMLOListElementClass, + toHTMLOListElement, + mkHTMLOListElement, unHTMLOListElement, + castToHTMLOListElement, gTypeHTMLOListElement, + HTMLObjectElement(HTMLObjectElement), HTMLObjectElementClass, + toHTMLObjectElement, + mkHTMLObjectElement, unHTMLObjectElement, + castToHTMLObjectElement, gTypeHTMLObjectElement, + HTMLOptGroupElement(HTMLOptGroupElement), HTMLOptGroupElementClass, + toHTMLOptGroupElement, + mkHTMLOptGroupElement, unHTMLOptGroupElement, + castToHTMLOptGroupElement, gTypeHTMLOptGroupElement, + HTMLOptionElement(HTMLOptionElement), HTMLOptionElementClass, + toHTMLOptionElement, + mkHTMLOptionElement, unHTMLOptionElement, + castToHTMLOptionElement, gTypeHTMLOptionElement, + HTMLParagraphElement(HTMLParagraphElement), HTMLParagraphElementClass, + toHTMLParagraphElement, + mkHTMLParagraphElement, unHTMLParagraphElement, + castToHTMLParagraphElement, gTypeHTMLParagraphElement, + HTMLParamElement(HTMLParamElement), HTMLParamElementClass, + toHTMLParamElement, + mkHTMLParamElement, unHTMLParamElement, + castToHTMLParamElement, gTypeHTMLParamElement, + HTMLPreElement(HTMLPreElement), HTMLPreElementClass, + toHTMLPreElement, + mkHTMLPreElement, unHTMLPreElement, + castToHTMLPreElement, gTypeHTMLPreElement, + HTMLQuoteElement(HTMLQuoteElement), HTMLQuoteElementClass, + toHTMLQuoteElement, + mkHTMLQuoteElement, unHTMLQuoteElement, + castToHTMLQuoteElement, gTypeHTMLQuoteElement, + HTMLScriptElement(HTMLScriptElement), HTMLScriptElementClass, + toHTMLScriptElement, + mkHTMLScriptElement, unHTMLScriptElement, + castToHTMLScriptElement, gTypeHTMLScriptElement, + HTMLSelectElement(HTMLSelectElement), HTMLSelectElementClass, + toHTMLSelectElement, + mkHTMLSelectElement, unHTMLSelectElement, + castToHTMLSelectElement, gTypeHTMLSelectElement, + HTMLStyleElement(HTMLStyleElement), HTMLStyleElementClass, + toHTMLStyleElement, + mkHTMLStyleElement, unHTMLStyleElement, + castToHTMLStyleElement, gTypeHTMLStyleElement, + HTMLTableCaptionElement(HTMLTableCaptionElement), HTMLTableCaptionElementClass, + toHTMLTableCaptionElement, + mkHTMLTableCaptionElement, unHTMLTableCaptionElement, + castToHTMLTableCaptionElement, gTypeHTMLTableCaptionElement, + HTMLTableCellElement(HTMLTableCellElement), HTMLTableCellElementClass, + toHTMLTableCellElement, + mkHTMLTableCellElement, unHTMLTableCellElement, + castToHTMLTableCellElement, gTypeHTMLTableCellElement, + HTMLTableColElement(HTMLTableColElement), HTMLTableColElementClass, + toHTMLTableColElement, + mkHTMLTableColElement, unHTMLTableColElement, + castToHTMLTableColElement, gTypeHTMLTableColElement, + HTMLTableElement(HTMLTableElement), HTMLTableElementClass, + toHTMLTableElement, + mkHTMLTableElement, unHTMLTableElement, + castToHTMLTableElement, gTypeHTMLTableElement, + HTMLTableRowElement(HTMLTableRowElement), HTMLTableRowElementClass, + toHTMLTableRowElement, + mkHTMLTableRowElement, unHTMLTableRowElement, + castToHTMLTableRowElement, gTypeHTMLTableRowElement, + HTMLTableSectionElement(HTMLTableSectionElement), HTMLTableSectionElementClass, + toHTMLTableSectionElement, + mkHTMLTableSectionElement, unHTMLTableSectionElement, + castToHTMLTableSectionElement, gTypeHTMLTableSectionElement, + HTMLTextAreaElement(HTMLTextAreaElement), HTMLTextAreaElementClass, + toHTMLTextAreaElement, + mkHTMLTextAreaElement, unHTMLTextAreaElement, + castToHTMLTextAreaElement, gTypeHTMLTextAreaElement, + HTMLTitleElement(HTMLTitleElement), HTMLTitleElementClass, + toHTMLTitleElement, + mkHTMLTitleElement, unHTMLTitleElement, + castToHTMLTitleElement, gTypeHTMLTitleElement, + HTMLUListElement(HTMLUListElement), HTMLUListElementClass, + toHTMLUListElement, + mkHTMLUListElement, unHTMLUListElement, + castToHTMLUListElement, gTypeHTMLUListElement, + EntityReference(EntityReference), EntityReferenceClass, + toEntityReference, + mkEntityReference, unEntityReference, + castToEntityReference, gTypeEntityReference, + Performance(Performance), PerformanceClass, + toPerformance, + mkPerformance, unPerformance, + castToPerformance, gTypePerformance, + TextTrack(TextTrack), TextTrackClass, + toTextTrack, + mkTextTrack, unTextTrack, + castToTextTrack, gTypeTextTrack, + TextTrackCue(TextTrackCue), TextTrackCueClass, + toTextTrackCue, + mkTextTrackCue, unTextTrackCue, + castToTextTrackCue, gTypeTextTrackCue, + TextTrackList(TextTrackList), TextTrackListClass, + toTextTrackList, + mkTextTrackList, unTextTrackList, + castToTextTrackList, gTypeTextTrackList, + VideoTrackList(VideoTrackList), VideoTrackListClass, + toVideoTrackList, + mkVideoTrackList, unVideoTrackList, + castToVideoTrackList, gTypeVideoTrackList, + WebKitNamedFlow(WebKitNamedFlow), WebKitNamedFlowClass, + toWebKitNamedFlow, + mkWebKitNamedFlow, unWebKitNamedFlow, + castToWebKitNamedFlow, gTypeWebKitNamedFlow, + Window(Window), WindowClass, + toWindow, + mkWindow, unWindow, + castToWindow, gTypeWindow, + FileList(FileList), FileListClass, + toFileList, + mkFileList, unFileList, + castToFileList, gTypeFileList, + Geolocation(Geolocation), GeolocationClass, + toGeolocation, + mkGeolocation, unGeolocation, + castToGeolocation, gTypeGeolocation, + HTMLCollection(HTMLCollection), HTMLCollectionClass, + toHTMLCollection, + mkHTMLCollection, unHTMLCollection, + castToHTMLCollection, gTypeHTMLCollection, + HTMLOptionsCollection(HTMLOptionsCollection), HTMLOptionsCollectionClass, + toHTMLOptionsCollection, + mkHTMLOptionsCollection, unHTMLOptionsCollection, + castToHTMLOptionsCollection, gTypeHTMLOptionsCollection, + HTMLMediaElement(HTMLMediaElement), HTMLMediaElementClass, + toHTMLMediaElement, + mkHTMLMediaElement, unHTMLMediaElement, + castToHTMLMediaElement, gTypeHTMLMediaElement, + HTMLAudioElement(HTMLAudioElement), HTMLAudioElementClass, + toHTMLAudioElement, + mkHTMLAudioElement, unHTMLAudioElement, + castToHTMLAudioElement, gTypeHTMLAudioElement, + HTMLVideoElement(HTMLVideoElement), HTMLVideoElementClass, + toHTMLVideoElement, + mkHTMLVideoElement, unHTMLVideoElement, + castToHTMLVideoElement, gTypeHTMLVideoElement, + History(History), HistoryClass, + toHistory, + mkHistory, unHistory, + castToHistory, gTypeHistory, + Location(Location), LocationClass, + toLocation, + mkLocation, unLocation, + castToLocation, gTypeLocation, + MediaError(MediaError), MediaErrorClass, + toMediaError, + mkMediaError, unMediaError, + castToMediaError, gTypeMediaError, + MediaList(MediaList), MediaListClass, + toMediaList, + mkMediaList, unMediaList, + castToMediaList, gTypeMediaList, + MediaQueryList(MediaQueryList), MediaQueryListClass, + toMediaQueryList, + mkMediaQueryList, unMediaQueryList, + castToMediaQueryList, gTypeMediaQueryList, + MimeType(MimeType), MimeTypeClass, + toMimeType, + mkMimeType, unMimeType, + castToMimeType, gTypeMimeType, + MimeTypeArray(MimeTypeArray), MimeTypeArrayClass, + toMimeTypeArray, + mkMimeTypeArray, unMimeTypeArray, + castToMimeTypeArray, gTypeMimeTypeArray, + NamedNodeMap(NamedNodeMap), NamedNodeMapClass, + toNamedNodeMap, + mkNamedNodeMap, unNamedNodeMap, + castToNamedNodeMap, gTypeNamedNodeMap, + Navigator(Navigator), NavigatorClass, + toNavigator, + mkNavigator, unNavigator, + castToNavigator, gTypeNavigator, + NodeFilter(NodeFilter), NodeFilterClass, + toNodeFilter, + mkNodeFilter, unNodeFilter, + castToNodeFilter, gTypeNodeFilter, + NodeIterator(NodeIterator), NodeIteratorClass, + toNodeIterator, + mkNodeIterator, unNodeIterator, + castToNodeIterator, gTypeNodeIterator, + NodeList(NodeList), NodeListClass, + toNodeList, + mkNodeList, unNodeList, + castToNodeList, gTypeNodeList, + PerformanceNavigation(PerformanceNavigation), PerformanceNavigationClass, + toPerformanceNavigation, + mkPerformanceNavigation, unPerformanceNavigation, + castToPerformanceNavigation, gTypePerformanceNavigation, + PerformanceTiming(PerformanceTiming), PerformanceTimingClass, + toPerformanceTiming, + mkPerformanceTiming, unPerformanceTiming, + castToPerformanceTiming, gTypePerformanceTiming, + Plugin(Plugin), PluginClass, + toPlugin, + mkPlugin, unPlugin, + castToPlugin, gTypePlugin, + PluginArray(PluginArray), PluginArrayClass, + toPluginArray, + mkPluginArray, unPluginArray, + castToPluginArray, gTypePluginArray, + Range(Range), RangeClass, + toRange, + mkRange, unRange, + castToRange, gTypeRange, + Screen(Screen), ScreenClass, + toScreen, + mkScreen, unScreen, + castToScreen, gTypeScreen, + SecurityPolicy(SecurityPolicy), SecurityPolicyClass, + toSecurityPolicy, + mkSecurityPolicy, unSecurityPolicy, + castToSecurityPolicy, gTypeSecurityPolicy, + Selection(Selection), SelectionClass, + toSelection, + mkSelection, unSelection, + castToSelection, gTypeSelection, + Storage(Storage), StorageClass, + toStorage, + mkStorage, unStorage, + castToStorage, gTypeStorage, + StorageInfo(StorageInfo), StorageInfoClass, + toStorageInfo, + mkStorageInfo, unStorageInfo, + castToStorageInfo, gTypeStorageInfo, + StorageQuota(StorageQuota), StorageQuotaClass, + toStorageQuota, + mkStorageQuota, unStorageQuota, + castToStorageQuota, gTypeStorageQuota, + StyleMedia(StyleMedia), StyleMediaClass, + toStyleMedia, + mkStyleMedia, unStyleMedia, + castToStyleMedia, gTypeStyleMedia, + StyleSheet(StyleSheet), StyleSheetClass, + toStyleSheet, + mkStyleSheet, unStyleSheet, + castToStyleSheet, gTypeStyleSheet, + CSSStyleSheet(CSSStyleSheet), CSSStyleSheetClass, + toCSSStyleSheet, + mkCSSStyleSheet, unCSSStyleSheet, + castToCSSStyleSheet, gTypeCSSStyleSheet, + StyleSheetList(StyleSheetList), StyleSheetListClass, + toStyleSheetList, + mkStyleSheetList, unStyleSheetList, + castToStyleSheetList, gTypeStyleSheetList, + TextTrackCueList(TextTrackCueList), TextTrackCueListClass, + toTextTrackCueList, + mkTextTrackCueList, unTextTrackCueList, + castToTextTrackCueList, gTypeTextTrackCueList, + TimeRanges(TimeRanges), TimeRangesClass, + toTimeRanges, + mkTimeRanges, unTimeRanges, + castToTimeRanges, gTypeTimeRanges, + Touch(Touch), TouchClass, + toTouch, + mkTouch, unTouch, + castToTouch, gTypeTouch, + TreeWalker(TreeWalker), TreeWalkerClass, + toTreeWalker, + mkTreeWalker, unTreeWalker, + castToTreeWalker, gTypeTreeWalker, + ValidityState(ValidityState), ValidityStateClass, + toValidityState, + mkValidityState, unValidityState, + castToValidityState, gTypeValidityState, + VideoTrack(VideoTrack), VideoTrackClass, + toVideoTrack, + mkVideoTrack, unVideoTrack, + castToVideoTrack, gTypeVideoTrack, + WebKitPoint(WebKitPoint), WebKitPointClass, + toWebKitPoint, + mkWebKitPoint, unWebKitPoint, + castToWebKitPoint, gTypeWebKitPoint, + XPathExpression(XPathExpression), XPathExpressionClass, + toXPathExpression, + mkXPathExpression, unXPathExpression, + castToXPathExpression, gTypeXPathExpression, + XPathNSResolver(XPathNSResolver), XPathNSResolverClass, + toXPathNSResolver, + mkXPathNSResolver, unXPathNSResolver, + castToXPathNSResolver, gTypeXPathNSResolver, + XPathResult(XPathResult), XPathResultClass, + toXPathResult, + mkXPathResult, unXPathResult, + castToXPathResult, gTypeXPathResult + ) where + +import Foreign.ForeignPtr (ForeignPtr, castForeignPtr) +#if __GLASGOW_HASKELL__ >= 707 +import Foreign.ForeignPtr.Unsafe (unsafeForeignPtrToPtr) +#else +import Foreign.ForeignPtr (unsafeForeignPtrToPtr) +#endif +import Foreign.C.Types (CULong(..), CUInt(..), CULLong(..)) +import System.Glib.GType (GType, typeInstanceIsA) +import Graphics.UI.Gtk.WebKit.GtkInternals + +{# context lib="gtk" prefix="gtk" #} + +-- The usage of foreignPtrToPtr should be safe as the evaluation will only be +-- forced if the object is used afterwards +-- +castTo :: (GObjectClass obj, GObjectClass obj') => GType -> String + -> (obj -> obj') +castTo gtype objTypeName obj = + case toGObject obj of + gobj@(GObject objFPtr) + | typeInstanceIsA ((unsafeForeignPtrToPtr.castForeignPtr) objFPtr) gtype + -> unsafeCastGObject gobj + | otherwise -> error $ "Cannot cast object to " ++ objTypeName + + +-- ******************************************************************** WebView + +{#pointer *WebKitWebView as WebView foreign newtype #} deriving (Eq,Ord) + +mkWebView = (WebView, objectUnrefFromMainloop) +unWebView (WebView o) = o + +class ContainerClass o => WebViewClass o +toWebView :: WebViewClass o => o -> WebView +toWebView = unsafeCastGObject . toGObject + +instance WebViewClass WebView +instance ContainerClass WebView +instance WidgetClass WebView +instance GObjectClass WebView where + toGObject = GObject . castForeignPtr . unWebView + unsafeCastGObject = WebView . castForeignPtr . unGObject + +castToWebView :: GObjectClass obj => obj -> WebView +castToWebView = castTo gTypeWebView "WebView" + +gTypeWebView :: GType +gTypeWebView = + {# call fun unsafe webkit_web_view_get_type #} + +-- ******************************************************************* WebFrame + +{#pointer *WebKitWebFrame as WebFrame foreign newtype #} deriving (Eq,Ord) + +mkWebFrame = (WebFrame, objectUnrefFromMainloop) +unWebFrame (WebFrame o) = o + +class GObjectClass o => WebFrameClass o +toWebFrame :: WebFrameClass o => o -> WebFrame +toWebFrame = unsafeCastGObject . toGObject + +instance WebFrameClass WebFrame +instance GObjectClass WebFrame where + toGObject = GObject . castForeignPtr . unWebFrame + unsafeCastGObject = WebFrame . castForeignPtr . unGObject + +castToWebFrame :: GObjectClass obj => obj -> WebFrame +castToWebFrame = castTo gTypeWebFrame "WebFrame" + +gTypeWebFrame :: GType +gTypeWebFrame = + {# call fun unsafe webkit_web_frame_get_type #} + +-- **************************************************************** WebSettings + +{#pointer *WebKitWebSettings as WebSettings foreign newtype #} deriving (Eq,Ord) + +mkWebSettings = (WebSettings, objectUnrefFromMainloop) +unWebSettings (WebSettings o) = o + +class GObjectClass o => WebSettingsClass o +toWebSettings :: WebSettingsClass o => o -> WebSettings +toWebSettings = unsafeCastGObject . toGObject + +instance WebSettingsClass WebSettings +instance GObjectClass WebSettings where + toGObject = GObject . castForeignPtr . unWebSettings + unsafeCastGObject = WebSettings . castForeignPtr . unGObject + +castToWebSettings :: GObjectClass obj => obj -> WebSettings +castToWebSettings = castTo gTypeWebSettings "WebSettings" + +gTypeWebSettings :: GType +gTypeWebSettings = + {# call fun unsafe webkit_web_settings_get_type #} + +-- ************************************************************* NetworkRequest + +{#pointer *WebKitNetworkRequest as NetworkRequest foreign newtype #} deriving (Eq,Ord) + +mkNetworkRequest = (NetworkRequest, objectUnrefFromMainloop) +unNetworkRequest (NetworkRequest o) = o + +class GObjectClass o => NetworkRequestClass o +toNetworkRequest :: NetworkRequestClass o => o -> NetworkRequest +toNetworkRequest = unsafeCastGObject . toGObject + +instance NetworkRequestClass NetworkRequest +instance GObjectClass NetworkRequest where + toGObject = GObject . castForeignPtr . unNetworkRequest + unsafeCastGObject = NetworkRequest . castForeignPtr . unGObject + +castToNetworkRequest :: GObjectClass obj => obj -> NetworkRequest +castToNetworkRequest = castTo gTypeNetworkRequest "NetworkRequest" + +gTypeNetworkRequest :: GType +gTypeNetworkRequest = + {# call fun unsafe webkit_network_request_get_type #} + +-- ************************************************************ NetworkResponse + +{#pointer *WebKitNetworkResponse as NetworkResponse foreign newtype #} deriving (Eq,Ord) + +mkNetworkResponse = (NetworkResponse, objectUnrefFromMainloop) +unNetworkResponse (NetworkResponse o) = o + +class GObjectClass o => NetworkResponseClass o +toNetworkResponse :: NetworkResponseClass o => o -> NetworkResponse +toNetworkResponse = unsafeCastGObject . toGObject + +instance NetworkResponseClass NetworkResponse +instance GObjectClass NetworkResponse where + toGObject = GObject . castForeignPtr . unNetworkResponse + unsafeCastGObject = NetworkResponse . castForeignPtr . unGObject + +castToNetworkResponse :: GObjectClass obj => obj -> NetworkResponse +castToNetworkResponse = castTo gTypeNetworkResponse "NetworkResponse" + +gTypeNetworkResponse :: GType +gTypeNetworkResponse = + {# call fun unsafe webkit_network_response_get_type #} + +-- ******************************************************************* Download + +{#pointer *WebKitDownload as Download foreign newtype #} deriving (Eq,Ord) + +mkDownload = (Download, objectUnrefFromMainloop) +unDownload (Download o) = o + +class GObjectClass o => DownloadClass o +toDownload :: DownloadClass o => o -> Download +toDownload = unsafeCastGObject . toGObject + +instance DownloadClass Download +instance GObjectClass Download where + toGObject = GObject . castForeignPtr . unDownload + unsafeCastGObject = Download . castForeignPtr . unGObject + +castToDownload :: GObjectClass obj => obj -> Download +castToDownload = castTo gTypeDownload "Download" + +gTypeDownload :: GType +gTypeDownload = + {# call fun unsafe webkit_download_get_type #} + +-- ********************************************************* WebBackForwardList + +{#pointer *WebKitWebBackForwardList as WebBackForwardList foreign newtype #} deriving (Eq,Ord) + +mkWebBackForwardList = (WebBackForwardList, objectUnrefFromMainloop) +unWebBackForwardList (WebBackForwardList o) = o + +class GObjectClass o => WebBackForwardListClass o +toWebBackForwardList :: WebBackForwardListClass o => o -> WebBackForwardList +toWebBackForwardList = unsafeCastGObject . toGObject + +instance WebBackForwardListClass WebBackForwardList +instance GObjectClass WebBackForwardList where + toGObject = GObject . castForeignPtr . unWebBackForwardList + unsafeCastGObject = WebBackForwardList . castForeignPtr . unGObject + +castToWebBackForwardList :: GObjectClass obj => obj -> WebBackForwardList +castToWebBackForwardList = castTo gTypeWebBackForwardList "WebBackForwardList" + +gTypeWebBackForwardList :: GType +gTypeWebBackForwardList = + {# call fun unsafe webkit_web_back_forward_list_get_type #} + +-- ************************************************************* WebHistoryItem + +{#pointer *WebKitWebHistoryItem as WebHistoryItem foreign newtype #} deriving (Eq,Ord) + +mkWebHistoryItem = (WebHistoryItem, objectUnrefFromMainloop) +unWebHistoryItem (WebHistoryItem o) = o + +class GObjectClass o => WebHistoryItemClass o +toWebHistoryItem :: WebHistoryItemClass o => o -> WebHistoryItem +toWebHistoryItem = unsafeCastGObject . toGObject + +instance WebHistoryItemClass WebHistoryItem +instance GObjectClass WebHistoryItem where + toGObject = GObject . castForeignPtr . unWebHistoryItem + unsafeCastGObject = WebHistoryItem . castForeignPtr . unGObject + +castToWebHistoryItem :: GObjectClass obj => obj -> WebHistoryItem +castToWebHistoryItem = castTo gTypeWebHistoryItem "WebHistoryItem" + +gTypeWebHistoryItem :: GType +gTypeWebHistoryItem = + {# call fun unsafe webkit_web_history_item_get_type #} + +-- *************************************************************** WebInspector + +{#pointer *WebKitWebInspector as WebInspector foreign newtype #} deriving (Eq,Ord) + +mkWebInspector = (WebInspector, objectUnrefFromMainloop) +unWebInspector (WebInspector o) = o + +class GObjectClass o => WebInspectorClass o +toWebInspector :: WebInspectorClass o => o -> WebInspector +toWebInspector = unsafeCastGObject . toGObject + +instance WebInspectorClass WebInspector +instance GObjectClass WebInspector where + toGObject = GObject . castForeignPtr . unWebInspector + unsafeCastGObject = WebInspector . castForeignPtr . unGObject + +castToWebInspector :: GObjectClass obj => obj -> WebInspector +castToWebInspector = castTo gTypeWebInspector "WebInspector" + +gTypeWebInspector :: GType +gTypeWebInspector = + {# call fun unsafe webkit_web_inspector_get_type #} + +-- ************************************************************** HitTestResult + +{#pointer *WebKitHitTestResult as HitTestResult foreign newtype #} deriving (Eq,Ord) + +mkHitTestResult = (HitTestResult, objectUnrefFromMainloop) +unHitTestResult (HitTestResult o) = o + +class GObjectClass o => HitTestResultClass o +toHitTestResult :: HitTestResultClass o => o -> HitTestResult +toHitTestResult = unsafeCastGObject . toGObject + +instance HitTestResultClass HitTestResult +instance GObjectClass HitTestResult where + toGObject = GObject . castForeignPtr . unHitTestResult + unsafeCastGObject = HitTestResult . castForeignPtr . unGObject + +castToHitTestResult :: GObjectClass obj => obj -> HitTestResult +castToHitTestResult = castTo gTypeHitTestResult "HitTestResult" + +gTypeHitTestResult :: GType +gTypeHitTestResult = + {# call fun unsafe webkit_hit_test_result_get_type #} + +-- ************************************************************* SecurityOrigin + +{#pointer *WebKitSecurityOrigin as SecurityOrigin foreign newtype #} deriving (Eq,Ord) + +mkSecurityOrigin = (SecurityOrigin, objectUnrefFromMainloop) +unSecurityOrigin (SecurityOrigin o) = o + +class GObjectClass o => SecurityOriginClass o +toSecurityOrigin :: SecurityOriginClass o => o -> SecurityOrigin +toSecurityOrigin = unsafeCastGObject . toGObject + +instance SecurityOriginClass SecurityOrigin +instance GObjectClass SecurityOrigin where + toGObject = GObject . castForeignPtr . unSecurityOrigin + unsafeCastGObject = SecurityOrigin . castForeignPtr . unGObject + +castToSecurityOrigin :: GObjectClass obj => obj -> SecurityOrigin +castToSecurityOrigin = castTo gTypeSecurityOrigin "SecurityOrigin" + +gTypeSecurityOrigin :: GType +gTypeSecurityOrigin = + {# call fun unsafe webkit_security_origin_get_type #} + +-- ************************************************************* SoupAuthDialog + +{#pointer *WebKitSoupAuthDialog as SoupAuthDialog foreign newtype #} deriving (Eq,Ord) + +mkSoupAuthDialog = (SoupAuthDialog, objectUnrefFromMainloop) +unSoupAuthDialog (SoupAuthDialog o) = o + +class GObjectClass o => SoupAuthDialogClass o +toSoupAuthDialog :: SoupAuthDialogClass o => o -> SoupAuthDialog +toSoupAuthDialog = unsafeCastGObject . toGObject + +instance SoupAuthDialogClass SoupAuthDialog +instance GObjectClass SoupAuthDialog where + toGObject = GObject . castForeignPtr . unSoupAuthDialog + unsafeCastGObject = SoupAuthDialog . castForeignPtr . unGObject + +castToSoupAuthDialog :: GObjectClass obj => obj -> SoupAuthDialog +castToSoupAuthDialog = castTo gTypeSoupAuthDialog "SoupAuthDialog" + +gTypeSoupAuthDialog :: GType +gTypeSoupAuthDialog = + {# call fun unsafe webkit_soup_auth_dialog_get_type #} + +-- **************************************************************** WebDatabase + +{#pointer *WebKitWebDatabase as WebDatabase foreign newtype #} deriving (Eq,Ord) + +mkWebDatabase = (WebDatabase, objectUnrefFromMainloop) +unWebDatabase (WebDatabase o) = o + +class GObjectClass o => WebDatabaseClass o +toWebDatabase :: WebDatabaseClass o => o -> WebDatabase +toWebDatabase = unsafeCastGObject . toGObject + +instance WebDatabaseClass WebDatabase +instance GObjectClass WebDatabase where + toGObject = GObject . castForeignPtr . unWebDatabase + unsafeCastGObject = WebDatabase . castForeignPtr . unGObject + +castToWebDatabase :: GObjectClass obj => obj -> WebDatabase +castToWebDatabase = castTo gTypeWebDatabase "WebDatabase" + +gTypeWebDatabase :: GType +gTypeWebDatabase = + {# call fun unsafe webkit_web_database_get_type #} + +-- ************************************************************** WebDataSource + +{#pointer *WebKitWebDataSource as WebDataSource foreign newtype #} deriving (Eq,Ord) + +mkWebDataSource = (WebDataSource, objectUnrefFromMainloop) +unWebDataSource (WebDataSource o) = o + +class GObjectClass o => WebDataSourceClass o +toWebDataSource :: WebDataSourceClass o => o -> WebDataSource +toWebDataSource = unsafeCastGObject . toGObject + +instance WebDataSourceClass WebDataSource +instance GObjectClass WebDataSource where + toGObject = GObject . castForeignPtr . unWebDataSource + unsafeCastGObject = WebDataSource . castForeignPtr . unGObject + +castToWebDataSource :: GObjectClass obj => obj -> WebDataSource +castToWebDataSource = castTo gTypeWebDataSource "WebDataSource" + +gTypeWebDataSource :: GType +gTypeWebDataSource = + {# call fun unsafe webkit_web_data_source_get_type #} + +-- ******************************************************** WebNavigationAction + +{#pointer *WebKitWebNavigationAction as WebNavigationAction foreign newtype #} deriving (Eq,Ord) + +mkWebNavigationAction = (WebNavigationAction, objectUnrefFromMainloop) +unWebNavigationAction (WebNavigationAction o) = o + +class GObjectClass o => WebNavigationActionClass o +toWebNavigationAction :: WebNavigationActionClass o => o -> WebNavigationAction +toWebNavigationAction = unsafeCastGObject . toGObject + +instance WebNavigationActionClass WebNavigationAction +instance GObjectClass WebNavigationAction where + toGObject = GObject . castForeignPtr . unWebNavigationAction + unsafeCastGObject = WebNavigationAction . castForeignPtr . unGObject + +castToWebNavigationAction :: GObjectClass obj => obj -> WebNavigationAction +castToWebNavigationAction = castTo gTypeWebNavigationAction "WebNavigationAction" + +gTypeWebNavigationAction :: GType +gTypeWebNavigationAction = + {# call fun unsafe webkit_web_navigation_action_get_type #} + +-- ********************************************************** WebPolicyDecision + +{#pointer *WebKitWebPolicyDecision as WebPolicyDecision foreign newtype #} deriving (Eq,Ord) + +mkWebPolicyDecision = (WebPolicyDecision, objectUnrefFromMainloop) +unWebPolicyDecision (WebPolicyDecision o) = o + +class GObjectClass o => WebPolicyDecisionClass o +toWebPolicyDecision :: WebPolicyDecisionClass o => o -> WebPolicyDecision +toWebPolicyDecision = unsafeCastGObject . toGObject + +instance WebPolicyDecisionClass WebPolicyDecision +instance GObjectClass WebPolicyDecision where + toGObject = GObject . castForeignPtr . unWebPolicyDecision + unsafeCastGObject = WebPolicyDecision . castForeignPtr . unGObject + +castToWebPolicyDecision :: GObjectClass obj => obj -> WebPolicyDecision +castToWebPolicyDecision = castTo gTypeWebPolicyDecision "WebPolicyDecision" + +gTypeWebPolicyDecision :: GType +gTypeWebPolicyDecision = + {# call fun unsafe webkit_web_policy_decision_get_type #} + +-- **************************************************************** WebResource + +{#pointer *WebKitWebResource as WebResource foreign newtype #} deriving (Eq,Ord) + +mkWebResource = (WebResource, objectUnrefFromMainloop) +unWebResource (WebResource o) = o + +class GObjectClass o => WebResourceClass o +toWebResource :: WebResourceClass o => o -> WebResource +toWebResource = unsafeCastGObject . toGObject + +instance WebResourceClass WebResource +instance GObjectClass WebResource where + toGObject = GObject . castForeignPtr . unWebResource + unsafeCastGObject = WebResource . castForeignPtr . unGObject + +castToWebResource :: GObjectClass obj => obj -> WebResource +castToWebResource = castTo gTypeWebResource "WebResource" + +gTypeWebResource :: GType +gTypeWebResource = + {# call fun unsafe webkit_web_resource_get_type #} + +-- ********************************************************** WebWindowFeatures + +{#pointer *WebKitWebWindowFeatures as WebWindowFeatures foreign newtype #} deriving (Eq,Ord) + +mkWebWindowFeatures = (WebWindowFeatures, objectUnrefFromMainloop) +unWebWindowFeatures (WebWindowFeatures o) = o + +class GObjectClass o => WebWindowFeaturesClass o +toWebWindowFeatures :: WebWindowFeaturesClass o => o -> WebWindowFeatures +toWebWindowFeatures = unsafeCastGObject . toGObject + +instance WebWindowFeaturesClass WebWindowFeatures +instance GObjectClass WebWindowFeatures where + toGObject = GObject . castForeignPtr . unWebWindowFeatures + unsafeCastGObject = WebWindowFeatures . castForeignPtr . unGObject + +castToWebWindowFeatures :: GObjectClass obj => obj -> WebWindowFeatures +castToWebWindowFeatures = castTo gTypeWebWindowFeatures "WebWindowFeatures" + +gTypeWebWindowFeatures :: GType +gTypeWebWindowFeatures = + {# call fun unsafe webkit_web_window_features_get_type #} + +-- ************************************************** GeolocationPolicyDecision + +{#pointer *WebKitGeolocationPolicyDecision as GeolocationPolicyDecision foreign newtype #} deriving (Eq,Ord) + +mkGeolocationPolicyDecision = (GeolocationPolicyDecision, objectUnrefFromMainloop) +unGeolocationPolicyDecision (GeolocationPolicyDecision o) = o + +class GObjectClass o => GeolocationPolicyDecisionClass o +toGeolocationPolicyDecision :: GeolocationPolicyDecisionClass o => o -> GeolocationPolicyDecision +toGeolocationPolicyDecision = unsafeCastGObject . toGObject + +instance GeolocationPolicyDecisionClass GeolocationPolicyDecision +instance GObjectClass GeolocationPolicyDecision where + toGObject = GObject . castForeignPtr . unGeolocationPolicyDecision + unsafeCastGObject = GeolocationPolicyDecision . castForeignPtr . unGObject + +castToGeolocationPolicyDecision :: GObjectClass obj => obj -> GeolocationPolicyDecision +castToGeolocationPolicyDecision = castTo gTypeGeolocationPolicyDecision "GeolocationPolicyDecision" + +gTypeGeolocationPolicyDecision :: GType +gTypeGeolocationPolicyDecision = + {# call fun unsafe webkit_geolocation_policy_decision_get_type #} + +-- ***************************************************************** AudioTrack + +{#pointer *WebKitDOMAudioTrack as AudioTrack foreign newtype #} deriving (Eq,Ord) + +mkAudioTrack = (AudioTrack, objectUnrefFromMainloop) +unAudioTrack (AudioTrack o) = o + +class GObjectClass o => AudioTrackClass o +toAudioTrack :: AudioTrackClass o => o -> AudioTrack +toAudioTrack = unsafeCastGObject . toGObject + +instance AudioTrackClass AudioTrack +instance GObjectClass AudioTrack where + toGObject = GObject . castForeignPtr . unAudioTrack + unsafeCastGObject = AudioTrack . castForeignPtr . unGObject + +castToAudioTrack :: GObjectClass obj => obj -> AudioTrack +castToAudioTrack = castTo gTypeAudioTrack "AudioTrack" + +gTypeAudioTrack :: GType +gTypeAudioTrack = + {# call fun unsafe webkit_dom_audio_track_get_type #} + +-- ******************************************************************** BarProp + +{#pointer *WebKitDOMBarProp as BarProp foreign newtype #} deriving (Eq,Ord) + +mkBarProp = (BarProp, objectUnrefFromMainloop) +unBarProp (BarProp o) = o + +class GObjectClass o => BarPropClass o +toBarProp :: BarPropClass o => o -> BarProp +toBarProp = unsafeCastGObject . toGObject + +instance BarPropClass BarProp +instance GObjectClass BarProp where + toGObject = GObject . castForeignPtr . unBarProp + unsafeCastGObject = BarProp . castForeignPtr . unGObject + +castToBarProp :: GObjectClass obj => obj -> BarProp +castToBarProp = castTo gTypeBarProp "BarProp" + +gTypeBarProp :: GType +gTypeBarProp = + {# call fun unsafe webkit_dom_bar_prop_get_type #} + +-- *********************************************************************** Blob + +{#pointer *WebKitDOMBlob as Blob foreign newtype #} deriving (Eq,Ord) + +mkBlob = (Blob, objectUnrefFromMainloop) +unBlob (Blob o) = o + +class GObjectClass o => BlobClass o +toBlob :: BlobClass o => o -> Blob +toBlob = unsafeCastGObject . toGObject + +instance BlobClass Blob +instance GObjectClass Blob where + toGObject = GObject . castForeignPtr . unBlob + unsafeCastGObject = Blob . castForeignPtr . unGObject + +castToBlob :: GObjectClass obj => obj -> Blob +castToBlob = castTo gTypeBlob "Blob" + +gTypeBlob :: GType +gTypeBlob = + {# call fun unsafe webkit_dom_blob_get_type #} + +-- *********************************************************************** File + +{#pointer *WebKitDOMFile as File foreign newtype #} deriving (Eq,Ord) + +mkFile = (File, objectUnrefFromMainloop) +unFile (File o) = o + +class BlobClass o => FileClass o +toFile :: FileClass o => o -> File +toFile = unsafeCastGObject . toGObject + +instance FileClass File +instance BlobClass File +instance GObjectClass File where + toGObject = GObject . castForeignPtr . unFile + unsafeCastGObject = File . castForeignPtr . unGObject + +castToFile :: GObjectClass obj => obj -> File +castToFile = castTo gTypeFile "File" + +gTypeFile :: GType +gTypeFile = + {# call fun unsafe webkit_dom_file_get_type #} + +-- ************************************************************************ CSS + +{#pointer *WebKitDOMDOMWindowCSS as CSS foreign newtype #} deriving (Eq,Ord) + +mkCSS = (CSS, objectUnrefFromMainloop) +unCSS (CSS o) = o + +class GObjectClass o => CSSClass o +toCSS :: CSSClass o => o -> CSS +toCSS = unsafeCastGObject . toGObject + +instance CSSClass CSS +instance GObjectClass CSS where + toGObject = GObject . castForeignPtr . unCSS + unsafeCastGObject = CSS . castForeignPtr . unGObject + +castToCSS :: GObjectClass obj => obj -> CSS +castToCSS = castTo gTypeCSS "CSS" + +gTypeCSS :: GType +gTypeCSS = + {# call fun unsafe webkit_dom_dom_window_css_get_type #} + +-- ******************************************************************** CSSRule + +{#pointer *WebKitDOMCSSRule as CSSRule foreign newtype #} deriving (Eq,Ord) + +mkCSSRule = (CSSRule, objectUnrefFromMainloop) +unCSSRule (CSSRule o) = o + +class GObjectClass o => CSSRuleClass o +toCSSRule :: CSSRuleClass o => o -> CSSRule +toCSSRule = unsafeCastGObject . toGObject + +instance CSSRuleClass CSSRule +instance GObjectClass CSSRule where + toGObject = GObject . castForeignPtr . unCSSRule + unsafeCastGObject = CSSRule . castForeignPtr . unGObject + +castToCSSRule :: GObjectClass obj => obj -> CSSRule +castToCSSRule = castTo gTypeCSSRule "CSSRule" + +gTypeCSSRule :: GType +gTypeCSSRule = + {# call fun unsafe webkit_dom_css_rule_get_type #} + +-- **************************************************************** CSSRuleList + +{#pointer *WebKitDOMCSSRuleList as CSSRuleList foreign newtype #} deriving (Eq,Ord) + +mkCSSRuleList = (CSSRuleList, objectUnrefFromMainloop) +unCSSRuleList (CSSRuleList o) = o + +class GObjectClass o => CSSRuleListClass o +toCSSRuleList :: CSSRuleListClass o => o -> CSSRuleList +toCSSRuleList = unsafeCastGObject . toGObject + +instance CSSRuleListClass CSSRuleList +instance GObjectClass CSSRuleList where + toGObject = GObject . castForeignPtr . unCSSRuleList + unsafeCastGObject = CSSRuleList . castForeignPtr . unGObject + +castToCSSRuleList :: GObjectClass obj => obj -> CSSRuleList +castToCSSRuleList = castTo gTypeCSSRuleList "CSSRuleList" + +gTypeCSSRuleList :: GType +gTypeCSSRuleList = + {# call fun unsafe webkit_dom_css_rule_list_get_type #} + +-- ******************************************************** CSSStyleDeclaration + +{#pointer *WebKitDOMCSSStyleDeclaration as CSSStyleDeclaration foreign newtype #} deriving (Eq,Ord) + +mkCSSStyleDeclaration = (CSSStyleDeclaration, objectUnrefFromMainloop) +unCSSStyleDeclaration (CSSStyleDeclaration o) = o + +class GObjectClass o => CSSStyleDeclarationClass o +toCSSStyleDeclaration :: CSSStyleDeclarationClass o => o -> CSSStyleDeclaration +toCSSStyleDeclaration = unsafeCastGObject . toGObject + +instance CSSStyleDeclarationClass CSSStyleDeclaration +instance GObjectClass CSSStyleDeclaration where + toGObject = GObject . castForeignPtr . unCSSStyleDeclaration + unsafeCastGObject = CSSStyleDeclaration . castForeignPtr . unGObject + +castToCSSStyleDeclaration :: GObjectClass obj => obj -> CSSStyleDeclaration +castToCSSStyleDeclaration = castTo gTypeCSSStyleDeclaration "CSSStyleDeclaration" + +gTypeCSSStyleDeclaration :: GType +gTypeCSSStyleDeclaration = + {# call fun unsafe webkit_dom_css_style_declaration_get_type #} + +-- ******************************************************************* CSSValue + +{#pointer *WebKitDOMCSSValue as CSSValue foreign newtype #} deriving (Eq,Ord) + +mkCSSValue = (CSSValue, objectUnrefFromMainloop) +unCSSValue (CSSValue o) = o + +class GObjectClass o => CSSValueClass o +toCSSValue :: CSSValueClass o => o -> CSSValue +toCSSValue = unsafeCastGObject . toGObject + +instance CSSValueClass CSSValue +instance GObjectClass CSSValue where + toGObject = GObject . castForeignPtr . unCSSValue + unsafeCastGObject = CSSValue . castForeignPtr . unGObject + +castToCSSValue :: GObjectClass obj => obj -> CSSValue +castToCSSValue = castTo gTypeCSSValue "CSSValue" + +gTypeCSSValue :: GType +gTypeCSSValue = + {# call fun unsafe webkit_dom_css_value_get_type #} + +-- ********************************************************** DOMImplementation + +{#pointer *WebKitDOMDOMImplementation as DOMImplementation foreign newtype #} deriving (Eq,Ord) + +mkDOMImplementation = (DOMImplementation, objectUnrefFromMainloop) +unDOMImplementation (DOMImplementation o) = o + +class GObjectClass o => DOMImplementationClass o +toDOMImplementation :: DOMImplementationClass o => o -> DOMImplementation +toDOMImplementation = unsafeCastGObject . toGObject + +instance DOMImplementationClass DOMImplementation +instance GObjectClass DOMImplementation where + toGObject = GObject . castForeignPtr . unDOMImplementation + unsafeCastGObject = DOMImplementation . castForeignPtr . unGObject + +castToDOMImplementation :: GObjectClass obj => obj -> DOMImplementation +castToDOMImplementation = castTo gTypeDOMImplementation "DOMImplementation" + +gTypeDOMImplementation :: GType +gTypeDOMImplementation = + {# call fun unsafe webkit_dom_dom_implementation_get_type #} + +-- ***************************************************** DOMNamedFlowCollection + +{#pointer *WebKitDOMDOMNamedFlowCollection as DOMNamedFlowCollection foreign newtype #} deriving (Eq,Ord) + +mkDOMNamedFlowCollection = (DOMNamedFlowCollection, objectUnrefFromMainloop) +unDOMNamedFlowCollection (DOMNamedFlowCollection o) = o + +class GObjectClass o => DOMNamedFlowCollectionClass o +toDOMNamedFlowCollection :: DOMNamedFlowCollectionClass o => o -> DOMNamedFlowCollection +toDOMNamedFlowCollection = unsafeCastGObject . toGObject + +instance DOMNamedFlowCollectionClass DOMNamedFlowCollection +instance GObjectClass DOMNamedFlowCollection where + toGObject = GObject . castForeignPtr . unDOMNamedFlowCollection + unsafeCastGObject = DOMNamedFlowCollection . castForeignPtr . unGObject + +castToDOMNamedFlowCollection :: GObjectClass obj => obj -> DOMNamedFlowCollection +castToDOMNamedFlowCollection = castTo gTypeDOMNamedFlowCollection "DOMNamedFlowCollection" + +gTypeDOMNamedFlowCollection :: GType +gTypeDOMNamedFlowCollection = + {# call fun unsafe webkit_dom_dom_named_flow_collection_get_type #} + +-- ************************************************************** DOMStringList + +{#pointer *WebKitDOMDOMStringList as DOMStringList foreign newtype #} deriving (Eq,Ord) + +mkDOMStringList = (DOMStringList, objectUnrefFromMainloop) +unDOMStringList (DOMStringList o) = o + +class GObjectClass o => DOMStringListClass o +toDOMStringList :: DOMStringListClass o => o -> DOMStringList +toDOMStringList = unsafeCastGObject . toGObject + +instance DOMStringListClass DOMStringList +instance GObjectClass DOMStringList where + toGObject = GObject . castForeignPtr . unDOMStringList + unsafeCastGObject = DOMStringList . castForeignPtr . unGObject + +castToDOMStringList :: GObjectClass obj => obj -> DOMStringList +castToDOMStringList = castTo gTypeDOMStringList "DOMStringList" + +gTypeDOMStringList :: GType +gTypeDOMStringList = + {# call fun unsafe webkit_dom_dom_string_list_get_type #} + +-- *************************************************************** DOMTokenList + +{#pointer *WebKitDOMDOMTokenList as DOMTokenList foreign newtype #} deriving (Eq,Ord) + +mkDOMTokenList = (DOMTokenList, objectUnrefFromMainloop) +unDOMTokenList (DOMTokenList o) = o + +class GObjectClass o => DOMTokenListClass o +toDOMTokenList :: DOMTokenListClass o => o -> DOMTokenList +toDOMTokenList = unsafeCastGObject . toGObject + +instance DOMTokenListClass DOMTokenList +instance GObjectClass DOMTokenList where + toGObject = GObject . castForeignPtr . unDOMTokenList + unsafeCastGObject = DOMTokenList . castForeignPtr . unGObject + +castToDOMTokenList :: GObjectClass obj => obj -> DOMTokenList +castToDOMTokenList = castTo gTypeDOMTokenList "DOMTokenList" + +gTypeDOMTokenList :: GType +gTypeDOMTokenList = + {# call fun unsafe webkit_dom_dom_token_list_get_type #} + +-- ******************************************************* DOMSettableTokenList + +{#pointer *WebKitDOMDOMSettableTokenList as DOMSettableTokenList foreign newtype #} deriving (Eq,Ord) + +mkDOMSettableTokenList = (DOMSettableTokenList, objectUnrefFromMainloop) +unDOMSettableTokenList (DOMSettableTokenList o) = o + +class DOMTokenListClass o => DOMSettableTokenListClass o +toDOMSettableTokenList :: DOMSettableTokenListClass o => o -> DOMSettableTokenList +toDOMSettableTokenList = unsafeCastGObject . toGObject + +instance DOMSettableTokenListClass DOMSettableTokenList +instance DOMTokenListClass DOMSettableTokenList +instance GObjectClass DOMSettableTokenList where + toGObject = GObject . castForeignPtr . unDOMSettableTokenList + unsafeCastGObject = DOMSettableTokenList . castForeignPtr . unGObject + +castToDOMSettableTokenList :: GObjectClass obj => obj -> DOMSettableTokenList +castToDOMSettableTokenList = castTo gTypeDOMSettableTokenList "DOMSettableTokenList" + +gTypeDOMSettableTokenList :: GType +gTypeDOMSettableTokenList = + {# call fun unsafe webkit_dom_dom_settable_token_list_get_type #} + +-- ********************************************************************** Event + +{#pointer *WebKitDOMEvent as Event foreign newtype #} deriving (Eq,Ord) + +mkEvent = (Event, objectUnrefFromMainloop) +unEvent (Event o) = o + +class GObjectClass o => EventClass o +toEvent :: EventClass o => o -> Event +toEvent = unsafeCastGObject . toGObject + +instance EventClass Event +instance GObjectClass Event where + toGObject = GObject . castForeignPtr . unEvent + unsafeCastGObject = Event . castForeignPtr . unGObject + +castToEvent :: GObjectClass obj => obj -> Event +castToEvent = castTo gTypeEvent "Event" + +gTypeEvent :: GType +gTypeEvent = + {# call fun unsafe webkit_dom_event_get_type #} + +-- ******************************************************************** UIEvent + +{#pointer *WebKitDOMUIEvent as UIEvent foreign newtype #} deriving (Eq,Ord) + +mkUIEvent = (UIEvent, objectUnrefFromMainloop) +unUIEvent (UIEvent o) = o + +class EventClass o => UIEventClass o +toUIEvent :: UIEventClass o => o -> UIEvent +toUIEvent = unsafeCastGObject . toGObject + +instance UIEventClass UIEvent +instance EventClass UIEvent +instance GObjectClass UIEvent where + toGObject = GObject . castForeignPtr . unUIEvent + unsafeCastGObject = UIEvent . castForeignPtr . unGObject + +castToUIEvent :: GObjectClass obj => obj -> UIEvent +castToUIEvent = castTo gTypeUIEvent "UIEvent" + +gTypeUIEvent :: GType +gTypeUIEvent = + {# call fun unsafe webkit_dom_ui_event_get_type #} + +-- ************************************************************** KeyboardEvent + +{#pointer *WebKitDOMKeyboardEvent as KeyboardEvent foreign newtype #} deriving (Eq,Ord) + +mkKeyboardEvent = (KeyboardEvent, objectUnrefFromMainloop) +unKeyboardEvent (KeyboardEvent o) = o + +class UIEventClass o => KeyboardEventClass o +toKeyboardEvent :: KeyboardEventClass o => o -> KeyboardEvent +toKeyboardEvent = unsafeCastGObject . toGObject + +instance KeyboardEventClass KeyboardEvent +instance UIEventClass KeyboardEvent +instance EventClass KeyboardEvent +instance GObjectClass KeyboardEvent where + toGObject = GObject . castForeignPtr . unKeyboardEvent + unsafeCastGObject = KeyboardEvent . castForeignPtr . unGObject + +castToKeyboardEvent :: GObjectClass obj => obj -> KeyboardEvent +castToKeyboardEvent = castTo gTypeKeyboardEvent "KeyboardEvent" + +gTypeKeyboardEvent :: GType +gTypeKeyboardEvent = + {# call fun unsafe webkit_dom_keyboard_event_get_type #} + +-- ***************************************************************** MouseEvent + +{#pointer *WebKitDOMMouseEvent as MouseEvent foreign newtype #} deriving (Eq,Ord) + +mkMouseEvent = (MouseEvent, objectUnrefFromMainloop) +unMouseEvent (MouseEvent o) = o + +class UIEventClass o => MouseEventClass o +toMouseEvent :: MouseEventClass o => o -> MouseEvent +toMouseEvent = unsafeCastGObject . toGObject + +instance MouseEventClass MouseEvent +instance UIEventClass MouseEvent +instance EventClass MouseEvent +instance GObjectClass MouseEvent where + toGObject = GObject . castForeignPtr . unMouseEvent + unsafeCastGObject = MouseEvent . castForeignPtr . unGObject + +castToMouseEvent :: GObjectClass obj => obj -> MouseEvent +castToMouseEvent = castTo gTypeMouseEvent "MouseEvent" + +gTypeMouseEvent :: GType +gTypeMouseEvent = + {# call fun unsafe webkit_dom_mouse_event_get_type #} + +-- ***************************************************************** WheelEvent + +{#pointer *WebKitDOMWheelEvent as WheelEvent foreign newtype #} deriving (Eq,Ord) + +mkWheelEvent = (WheelEvent, objectUnrefFromMainloop) +unWheelEvent (WheelEvent o) = o + +class MouseEventClass o => WheelEventClass o +toWheelEvent :: WheelEventClass o => o -> WheelEvent +toWheelEvent = unsafeCastGObject . toGObject + +instance WheelEventClass WheelEvent +instance MouseEventClass WheelEvent +instance UIEventClass WheelEvent +instance EventClass WheelEvent +instance GObjectClass WheelEvent where + toGObject = GObject . castForeignPtr . unWheelEvent + unsafeCastGObject = WheelEvent . castForeignPtr . unGObject + +castToWheelEvent :: GObjectClass obj => obj -> WheelEvent +castToWheelEvent = castTo gTypeWheelEvent "WheelEvent" + +gTypeWheelEvent :: GType +gTypeWheelEvent = + {# call fun unsafe webkit_dom_wheel_event_get_type #} + +-- **************************************************************** EventTarget + +{#pointer *WebKitDOMEventTarget as EventTarget foreign newtype #} deriving (Eq,Ord) + +mkEventTarget = (EventTarget, objectUnrefFromMainloop) +unEventTarget (EventTarget o) = o + +class GObjectClass o => EventTargetClass o +toEventTarget :: EventTargetClass o => o -> EventTarget +toEventTarget = unsafeCastGObject . toGObject + +instance EventTargetClass EventTarget +instance GObjectClass EventTarget where + toGObject = GObject . castForeignPtr . unEventTarget + unsafeCastGObject = EventTarget . castForeignPtr . unGObject + +castToEventTarget :: GObjectClass obj => obj -> EventTarget +castToEventTarget = castTo gTypeEventTarget "EventTarget" + +gTypeEventTarget :: GType +gTypeEventTarget = + {# call fun unsafe webkit_dom_event_target_get_type #} + +-- *********************************************************** ApplicationCache + +{#pointer *WebKitDOMDOMApplicationCache as ApplicationCache foreign newtype #} deriving (Eq,Ord) + +mkApplicationCache = (ApplicationCache, objectUnrefFromMainloop) +unApplicationCache (ApplicationCache o) = o + +class EventTargetClass o => ApplicationCacheClass o +toApplicationCache :: ApplicationCacheClass o => o -> ApplicationCache +toApplicationCache = unsafeCastGObject . toGObject + +instance ApplicationCacheClass ApplicationCache +instance EventTargetClass ApplicationCache +instance GObjectClass ApplicationCache where + toGObject = GObject . castForeignPtr . unApplicationCache + unsafeCastGObject = ApplicationCache . castForeignPtr . unGObject + +castToApplicationCache :: GObjectClass obj => obj -> ApplicationCache +castToApplicationCache = castTo gTypeApplicationCache "ApplicationCache" + +gTypeApplicationCache :: GType +gTypeApplicationCache = + {# call fun unsafe webkit_dom_dom_application_cache_get_type #} + +-- ************************************************************* AudioTrackList + +{#pointer *WebKitDOMAudioTrackList as AudioTrackList foreign newtype #} deriving (Eq,Ord) + +mkAudioTrackList = (AudioTrackList, objectUnrefFromMainloop) +unAudioTrackList (AudioTrackList o) = o + +class EventTargetClass o => AudioTrackListClass o +toAudioTrackList :: AudioTrackListClass o => o -> AudioTrackList +toAudioTrackList = unsafeCastGObject . toGObject + +instance AudioTrackListClass AudioTrackList +instance EventTargetClass AudioTrackList +instance GObjectClass AudioTrackList where + toGObject = GObject . castForeignPtr . unAudioTrackList + unsafeCastGObject = AudioTrackList . castForeignPtr . unGObject + +castToAudioTrackList :: GObjectClass obj => obj -> AudioTrackList +castToAudioTrackList = castTo gTypeAudioTrackList "AudioTrackList" + +gTypeAudioTrackList :: GType +gTypeAudioTrackList = + {# call fun unsafe webkit_dom_audio_track_list_get_type #} + +-- ************************************************************* BatteryManager + +{#pointer *WebKitDOMBatteryManager as BatteryManager foreign newtype #} deriving (Eq,Ord) + +mkBatteryManager = (BatteryManager, objectUnrefFromMainloop) +unBatteryManager (BatteryManager o) = o + +class EventTargetClass o => BatteryManagerClass o +toBatteryManager :: BatteryManagerClass o => o -> BatteryManager +toBatteryManager = unsafeCastGObject . toGObject + +instance BatteryManagerClass BatteryManager +instance EventTargetClass BatteryManager +instance GObjectClass BatteryManager where + toGObject = GObject . castForeignPtr . unBatteryManager + unsafeCastGObject = BatteryManager . castForeignPtr . unGObject + +castToBatteryManager :: GObjectClass obj => obj -> BatteryManager +castToBatteryManager = castTo gTypeBatteryManager "BatteryManager" + +gTypeBatteryManager :: GType +gTypeBatteryManager = + {# call fun unsafe webkit_dom_battery_manager_get_type #} + +-- **************************************************************** MessagePort + +{#pointer *WebKitDOMMessagePort as MessagePort foreign newtype #} deriving (Eq,Ord) + +mkMessagePort = (MessagePort, objectUnrefFromMainloop) +unMessagePort (MessagePort o) = o + +class EventTargetClass o => MessagePortClass o +toMessagePort :: MessagePortClass o => o -> MessagePort +toMessagePort = unsafeCastGObject . toGObject + +instance MessagePortClass MessagePort +instance EventTargetClass MessagePort +instance GObjectClass MessagePort where + toGObject = GObject . castForeignPtr . unMessagePort + unsafeCastGObject = MessagePort . castForeignPtr . unGObject + +castToMessagePort :: GObjectClass obj => obj -> MessagePort +castToMessagePort = castTo gTypeMessagePort "MessagePort" + +gTypeMessagePort :: GType +gTypeMessagePort = + {# call fun unsafe webkit_dom_message_port_get_type #} + +-- *********************************************************************** Node + +{#pointer *WebKitDOMNode as Node foreign newtype #} deriving (Eq,Ord) + +mkNode = (Node, objectUnrefFromMainloop) +unNode (Node o) = o + +class EventTargetClass o => NodeClass o +toNode :: NodeClass o => o -> Node +toNode = unsafeCastGObject . toGObject + +instance NodeClass Node +instance EventTargetClass Node +instance GObjectClass Node where + toGObject = GObject . castForeignPtr . unNode + unsafeCastGObject = Node . castForeignPtr . unGObject + +castToNode :: GObjectClass obj => obj -> Node +castToNode = castTo gTypeNode "Node" + +gTypeNode :: GType +gTypeNode = + {# call fun unsafe webkit_dom_node_get_type #} + +-- *********************************************************************** Attr + +{#pointer *WebKitDOMAttr as Attr foreign newtype #} deriving (Eq,Ord) + +mkAttr = (Attr, objectUnrefFromMainloop) +unAttr (Attr o) = o + +class NodeClass o => AttrClass o +toAttr :: AttrClass o => o -> Attr +toAttr = unsafeCastGObject . toGObject + +instance AttrClass Attr +instance NodeClass Attr +instance EventTargetClass Attr +instance GObjectClass Attr where + toGObject = GObject . castForeignPtr . unAttr + unsafeCastGObject = Attr . castForeignPtr . unGObject + +castToAttr :: GObjectClass obj => obj -> Attr +castToAttr = castTo gTypeAttr "Attr" + +gTypeAttr :: GType +gTypeAttr = + {# call fun unsafe webkit_dom_attr_get_type #} + +-- ************************************************************** CharacterData + +{#pointer *WebKitDOMCharacterData as CharacterData foreign newtype #} deriving (Eq,Ord) + +mkCharacterData = (CharacterData, objectUnrefFromMainloop) +unCharacterData (CharacterData o) = o + +class NodeClass o => CharacterDataClass o +toCharacterData :: CharacterDataClass o => o -> CharacterData +toCharacterData = unsafeCastGObject . toGObject + +instance CharacterDataClass CharacterData +instance NodeClass CharacterData +instance EventTargetClass CharacterData +instance GObjectClass CharacterData where + toGObject = GObject . castForeignPtr . unCharacterData + unsafeCastGObject = CharacterData . castForeignPtr . unGObject + +castToCharacterData :: GObjectClass obj => obj -> CharacterData +castToCharacterData = castTo gTypeCharacterData "CharacterData" + +gTypeCharacterData :: GType +gTypeCharacterData = + {# call fun unsafe webkit_dom_character_data_get_type #} + +-- ******************************************************************** Comment + +{#pointer *WebKitDOMComment as Comment foreign newtype #} deriving (Eq,Ord) + +mkComment = (Comment, objectUnrefFromMainloop) +unComment (Comment o) = o + +class CharacterDataClass o => CommentClass o +toComment :: CommentClass o => o -> Comment +toComment = unsafeCastGObject . toGObject + +instance CommentClass Comment +instance CharacterDataClass Comment +instance NodeClass Comment +instance EventTargetClass Comment +instance GObjectClass Comment where + toGObject = GObject . castForeignPtr . unComment + unsafeCastGObject = Comment . castForeignPtr . unGObject + +castToComment :: GObjectClass obj => obj -> Comment +castToComment = castTo gTypeComment "Comment" + +gTypeComment :: GType +gTypeComment = + {# call fun unsafe webkit_dom_comment_get_type #} + +-- ****************************************************** ProcessingInstruction + +{#pointer *WebKitDOMProcessingInstruction as ProcessingInstruction foreign newtype #} deriving (Eq,Ord) + +mkProcessingInstruction = (ProcessingInstruction, objectUnrefFromMainloop) +unProcessingInstruction (ProcessingInstruction o) = o + +class CharacterDataClass o => ProcessingInstructionClass o +toProcessingInstruction :: ProcessingInstructionClass o => o -> ProcessingInstruction +toProcessingInstruction = unsafeCastGObject . toGObject + +instance ProcessingInstructionClass ProcessingInstruction +instance CharacterDataClass ProcessingInstruction +instance NodeClass ProcessingInstruction +instance EventTargetClass ProcessingInstruction +instance GObjectClass ProcessingInstruction where + toGObject = GObject . castForeignPtr . unProcessingInstruction + unsafeCastGObject = ProcessingInstruction . castForeignPtr . unGObject + +castToProcessingInstruction :: GObjectClass obj => obj -> ProcessingInstruction +castToProcessingInstruction = castTo gTypeProcessingInstruction "ProcessingInstruction" + +gTypeProcessingInstruction :: GType +gTypeProcessingInstruction = + {# call fun unsafe webkit_dom_processing_instruction_get_type #} + +-- *********************************************************************** Text + +{#pointer *WebKitDOMText as Text foreign newtype #} deriving (Eq,Ord) + +mkText = (Text, objectUnrefFromMainloop) +unText (Text o) = o + +class CharacterDataClass o => TextClass o +toText :: TextClass o => o -> Text +toText = unsafeCastGObject . toGObject + +instance TextClass Text +instance CharacterDataClass Text +instance NodeClass Text +instance EventTargetClass Text +instance GObjectClass Text where + toGObject = GObject . castForeignPtr . unText + unsafeCastGObject = Text . castForeignPtr . unGObject + +castToText :: GObjectClass obj => obj -> Text +castToText = castTo gTypeText "Text" + +gTypeText :: GType +gTypeText = + {# call fun unsafe webkit_dom_text_get_type #} + +-- *************************************************************** CDATASection + +{#pointer *WebKitDOMCDATASection as CDATASection foreign newtype #} deriving (Eq,Ord) + +mkCDATASection = (CDATASection, objectUnrefFromMainloop) +unCDATASection (CDATASection o) = o + +class TextClass o => CDATASectionClass o +toCDATASection :: CDATASectionClass o => o -> CDATASection +toCDATASection = unsafeCastGObject . toGObject + +instance CDATASectionClass CDATASection +instance TextClass CDATASection +instance CharacterDataClass CDATASection +instance NodeClass CDATASection +instance EventTargetClass CDATASection +instance GObjectClass CDATASection where + toGObject = GObject . castForeignPtr . unCDATASection + unsafeCastGObject = CDATASection . castForeignPtr . unGObject + +castToCDATASection :: GObjectClass obj => obj -> CDATASection +castToCDATASection = castTo gTypeCDATASection "CDATASection" + +gTypeCDATASection :: GType +gTypeCDATASection = + {# call fun unsafe webkit_dom_cdata_section_get_type #} + +-- ******************************************************************* Document + +{#pointer *WebKitDOMDocument as Document foreign newtype #} deriving (Eq,Ord) + +mkDocument = (Document, objectUnrefFromMainloop) +unDocument (Document o) = o + +class NodeClass o => DocumentClass o +toDocument :: DocumentClass o => o -> Document +toDocument = unsafeCastGObject . toGObject + +instance DocumentClass Document +instance NodeClass Document +instance EventTargetClass Document +instance GObjectClass Document where + toGObject = GObject . castForeignPtr . unDocument + unsafeCastGObject = Document . castForeignPtr . unGObject + +castToDocument :: GObjectClass obj => obj -> Document +castToDocument = castTo gTypeDocument "Document" + +gTypeDocument :: GType +gTypeDocument = + {# call fun unsafe webkit_dom_document_get_type #} + +-- *************************************************************** HTMLDocument + +{#pointer *WebKitDOMHTMLDocument as HTMLDocument foreign newtype #} deriving (Eq,Ord) + +mkHTMLDocument = (HTMLDocument, objectUnrefFromMainloop) +unHTMLDocument (HTMLDocument o) = o + +class DocumentClass o => HTMLDocumentClass o +toHTMLDocument :: HTMLDocumentClass o => o -> HTMLDocument +toHTMLDocument = unsafeCastGObject . toGObject + +instance HTMLDocumentClass HTMLDocument +instance DocumentClass HTMLDocument +instance NodeClass HTMLDocument +instance EventTargetClass HTMLDocument +instance GObjectClass HTMLDocument where + toGObject = GObject . castForeignPtr . unHTMLDocument + unsafeCastGObject = HTMLDocument . castForeignPtr . unGObject + +castToHTMLDocument :: GObjectClass obj => obj -> HTMLDocument +castToHTMLDocument = castTo gTypeHTMLDocument "HTMLDocument" + +gTypeHTMLDocument :: GType +gTypeHTMLDocument = + {# call fun unsafe webkit_dom_html_document_get_type #} + +-- *********************************************************** DocumentFragment + +{#pointer *WebKitDOMDocumentFragment as DocumentFragment foreign newtype #} deriving (Eq,Ord) + +mkDocumentFragment = (DocumentFragment, objectUnrefFromMainloop) +unDocumentFragment (DocumentFragment o) = o + +class NodeClass o => DocumentFragmentClass o +toDocumentFragment :: DocumentFragmentClass o => o -> DocumentFragment +toDocumentFragment = unsafeCastGObject . toGObject + +instance DocumentFragmentClass DocumentFragment +instance NodeClass DocumentFragment +instance EventTargetClass DocumentFragment +instance GObjectClass DocumentFragment where + toGObject = GObject . castForeignPtr . unDocumentFragment + unsafeCastGObject = DocumentFragment . castForeignPtr . unGObject + +castToDocumentFragment :: GObjectClass obj => obj -> DocumentFragment +castToDocumentFragment = castTo gTypeDocumentFragment "DocumentFragment" + +gTypeDocumentFragment :: GType +gTypeDocumentFragment = + {# call fun unsafe webkit_dom_document_fragment_get_type #} + +-- *************************************************************** DocumentType + +{#pointer *WebKitDOMDocumentType as DocumentType foreign newtype #} deriving (Eq,Ord) + +mkDocumentType = (DocumentType, objectUnrefFromMainloop) +unDocumentType (DocumentType o) = o + +class NodeClass o => DocumentTypeClass o +toDocumentType :: DocumentTypeClass o => o -> DocumentType +toDocumentType = unsafeCastGObject . toGObject + +instance DocumentTypeClass DocumentType +instance NodeClass DocumentType +instance EventTargetClass DocumentType +instance GObjectClass DocumentType where + toGObject = GObject . castForeignPtr . unDocumentType + unsafeCastGObject = DocumentType . castForeignPtr . unGObject + +castToDocumentType :: GObjectClass obj => obj -> DocumentType +castToDocumentType = castTo gTypeDocumentType "DocumentType" + +gTypeDocumentType :: GType +gTypeDocumentType = + {# call fun unsafe webkit_dom_document_type_get_type #} + +-- ******************************************************************** Element + +{#pointer *WebKitDOMElement as Element foreign newtype #} deriving (Eq,Ord) + +mkElement = (Element, objectUnrefFromMainloop) +unElement (Element o) = o + +class NodeClass o => ElementClass o +toElement :: ElementClass o => o -> Element +toElement = unsafeCastGObject . toGObject + +instance ElementClass Element +instance NodeClass Element +instance EventTargetClass Element +instance GObjectClass Element where + toGObject = GObject . castForeignPtr . unElement + unsafeCastGObject = Element . castForeignPtr . unGObject + +castToElement :: GObjectClass obj => obj -> Element +castToElement = castTo gTypeElement "Element" + +gTypeElement :: GType +gTypeElement = + {# call fun unsafe webkit_dom_element_get_type #} + +-- **************************************************************** HTMLElement + +{#pointer *WebKitDOMHTMLElement as HTMLElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLElement = (HTMLElement, objectUnrefFromMainloop) +unHTMLElement (HTMLElement o) = o + +class ElementClass o => HTMLElementClass o +toHTMLElement :: HTMLElementClass o => o -> HTMLElement +toHTMLElement = unsafeCastGObject . toGObject + +instance HTMLElementClass HTMLElement +instance ElementClass HTMLElement +instance NodeClass HTMLElement +instance EventTargetClass HTMLElement +instance GObjectClass HTMLElement where + toGObject = GObject . castForeignPtr . unHTMLElement + unsafeCastGObject = HTMLElement . castForeignPtr . unGObject + +castToHTMLElement :: GObjectClass obj => obj -> HTMLElement +castToHTMLElement = castTo gTypeHTMLElement "HTMLElement" + +gTypeHTMLElement :: GType +gTypeHTMLElement = + {# call fun unsafe webkit_dom_html_element_get_type #} + +-- ********************************************************** HTMLAnchorElement + +{#pointer *WebKitDOMHTMLAnchorElement as HTMLAnchorElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLAnchorElement = (HTMLAnchorElement, objectUnrefFromMainloop) +unHTMLAnchorElement (HTMLAnchorElement o) = o + +class HTMLElementClass o => HTMLAnchorElementClass o +toHTMLAnchorElement :: HTMLAnchorElementClass o => o -> HTMLAnchorElement +toHTMLAnchorElement = unsafeCastGObject . toGObject + +instance HTMLAnchorElementClass HTMLAnchorElement +instance HTMLElementClass HTMLAnchorElement +instance ElementClass HTMLAnchorElement +instance NodeClass HTMLAnchorElement +instance EventTargetClass HTMLAnchorElement +instance GObjectClass HTMLAnchorElement where + toGObject = GObject . castForeignPtr . unHTMLAnchorElement + unsafeCastGObject = HTMLAnchorElement . castForeignPtr . unGObject + +castToHTMLAnchorElement :: GObjectClass obj => obj -> HTMLAnchorElement +castToHTMLAnchorElement = castTo gTypeHTMLAnchorElement "HTMLAnchorElement" + +gTypeHTMLAnchorElement :: GType +gTypeHTMLAnchorElement = + {# call fun unsafe webkit_dom_html_anchor_element_get_type #} + +-- ********************************************************** HTMLAppletElement + +{#pointer *WebKitDOMHTMLAppletElement as HTMLAppletElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLAppletElement = (HTMLAppletElement, objectUnrefFromMainloop) +unHTMLAppletElement (HTMLAppletElement o) = o + +class HTMLElementClass o => HTMLAppletElementClass o +toHTMLAppletElement :: HTMLAppletElementClass o => o -> HTMLAppletElement +toHTMLAppletElement = unsafeCastGObject . toGObject + +instance HTMLAppletElementClass HTMLAppletElement +instance HTMLElementClass HTMLAppletElement +instance ElementClass HTMLAppletElement +instance NodeClass HTMLAppletElement +instance EventTargetClass HTMLAppletElement +instance GObjectClass HTMLAppletElement where + toGObject = GObject . castForeignPtr . unHTMLAppletElement + unsafeCastGObject = HTMLAppletElement . castForeignPtr . unGObject + +castToHTMLAppletElement :: GObjectClass obj => obj -> HTMLAppletElement +castToHTMLAppletElement = castTo gTypeHTMLAppletElement "HTMLAppletElement" + +gTypeHTMLAppletElement :: GType +gTypeHTMLAppletElement = + {# call fun unsafe webkit_dom_html_applet_element_get_type #} + +-- ************************************************************ HTMLAreaElement + +{#pointer *WebKitDOMHTMLAreaElement as HTMLAreaElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLAreaElement = (HTMLAreaElement, objectUnrefFromMainloop) +unHTMLAreaElement (HTMLAreaElement o) = o + +class HTMLElementClass o => HTMLAreaElementClass o +toHTMLAreaElement :: HTMLAreaElementClass o => o -> HTMLAreaElement +toHTMLAreaElement = unsafeCastGObject . toGObject + +instance HTMLAreaElementClass HTMLAreaElement +instance HTMLElementClass HTMLAreaElement +instance ElementClass HTMLAreaElement +instance NodeClass HTMLAreaElement +instance EventTargetClass HTMLAreaElement +instance GObjectClass HTMLAreaElement where + toGObject = GObject . castForeignPtr . unHTMLAreaElement + unsafeCastGObject = HTMLAreaElement . castForeignPtr . unGObject + +castToHTMLAreaElement :: GObjectClass obj => obj -> HTMLAreaElement +castToHTMLAreaElement = castTo gTypeHTMLAreaElement "HTMLAreaElement" + +gTypeHTMLAreaElement :: GType +gTypeHTMLAreaElement = + {# call fun unsafe webkit_dom_html_area_element_get_type #} + +-- ************************************************************** HTMLBRElement + +{#pointer *WebKitDOMHTMLBRElement as HTMLBRElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLBRElement = (HTMLBRElement, objectUnrefFromMainloop) +unHTMLBRElement (HTMLBRElement o) = o + +class HTMLElementClass o => HTMLBRElementClass o +toHTMLBRElement :: HTMLBRElementClass o => o -> HTMLBRElement +toHTMLBRElement = unsafeCastGObject . toGObject + +instance HTMLBRElementClass HTMLBRElement +instance HTMLElementClass HTMLBRElement +instance ElementClass HTMLBRElement +instance NodeClass HTMLBRElement +instance EventTargetClass HTMLBRElement +instance GObjectClass HTMLBRElement where + toGObject = GObject . castForeignPtr . unHTMLBRElement + unsafeCastGObject = HTMLBRElement . castForeignPtr . unGObject + +castToHTMLBRElement :: GObjectClass obj => obj -> HTMLBRElement +castToHTMLBRElement = castTo gTypeHTMLBRElement "HTMLBRElement" + +gTypeHTMLBRElement :: GType +gTypeHTMLBRElement = + {# call fun unsafe webkit_dom_htmlbr_element_get_type #} + +-- ************************************************************ HTMLBaseElement + +{#pointer *WebKitDOMHTMLBaseElement as HTMLBaseElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLBaseElement = (HTMLBaseElement, objectUnrefFromMainloop) +unHTMLBaseElement (HTMLBaseElement o) = o + +class HTMLElementClass o => HTMLBaseElementClass o +toHTMLBaseElement :: HTMLBaseElementClass o => o -> HTMLBaseElement +toHTMLBaseElement = unsafeCastGObject . toGObject + +instance HTMLBaseElementClass HTMLBaseElement +instance HTMLElementClass HTMLBaseElement +instance ElementClass HTMLBaseElement +instance NodeClass HTMLBaseElement +instance EventTargetClass HTMLBaseElement +instance GObjectClass HTMLBaseElement where + toGObject = GObject . castForeignPtr . unHTMLBaseElement + unsafeCastGObject = HTMLBaseElement . castForeignPtr . unGObject + +castToHTMLBaseElement :: GObjectClass obj => obj -> HTMLBaseElement +castToHTMLBaseElement = castTo gTypeHTMLBaseElement "HTMLBaseElement" + +gTypeHTMLBaseElement :: GType +gTypeHTMLBaseElement = + {# call fun unsafe webkit_dom_html_base_element_get_type #} + +-- ******************************************************** HTMLBaseFontElement + +{#pointer *WebKitDOMHTMLBaseFontElement as HTMLBaseFontElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLBaseFontElement = (HTMLBaseFontElement, objectUnrefFromMainloop) +unHTMLBaseFontElement (HTMLBaseFontElement o) = o + +class HTMLElementClass o => HTMLBaseFontElementClass o +toHTMLBaseFontElement :: HTMLBaseFontElementClass o => o -> HTMLBaseFontElement +toHTMLBaseFontElement = unsafeCastGObject . toGObject + +instance HTMLBaseFontElementClass HTMLBaseFontElement +instance HTMLElementClass HTMLBaseFontElement +instance ElementClass HTMLBaseFontElement +instance NodeClass HTMLBaseFontElement +instance EventTargetClass HTMLBaseFontElement +instance GObjectClass HTMLBaseFontElement where + toGObject = GObject . castForeignPtr . unHTMLBaseFontElement + unsafeCastGObject = HTMLBaseFontElement . castForeignPtr . unGObject + +castToHTMLBaseFontElement :: GObjectClass obj => obj -> HTMLBaseFontElement +castToHTMLBaseFontElement = castTo gTypeHTMLBaseFontElement "HTMLBaseFontElement" + +gTypeHTMLBaseFontElement :: GType +gTypeHTMLBaseFontElement = + {# call fun unsafe webkit_dom_html_base_font_element_get_type #} + +-- ************************************************************ HTMLBodyElement + +{#pointer *WebKitDOMHTMLBodyElement as HTMLBodyElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLBodyElement = (HTMLBodyElement, objectUnrefFromMainloop) +unHTMLBodyElement (HTMLBodyElement o) = o + +class HTMLElementClass o => HTMLBodyElementClass o +toHTMLBodyElement :: HTMLBodyElementClass o => o -> HTMLBodyElement +toHTMLBodyElement = unsafeCastGObject . toGObject + +instance HTMLBodyElementClass HTMLBodyElement +instance HTMLElementClass HTMLBodyElement +instance ElementClass HTMLBodyElement +instance NodeClass HTMLBodyElement +instance EventTargetClass HTMLBodyElement +instance GObjectClass HTMLBodyElement where + toGObject = GObject . castForeignPtr . unHTMLBodyElement + unsafeCastGObject = HTMLBodyElement . castForeignPtr . unGObject + +castToHTMLBodyElement :: GObjectClass obj => obj -> HTMLBodyElement +castToHTMLBodyElement = castTo gTypeHTMLBodyElement "HTMLBodyElement" + +gTypeHTMLBodyElement :: GType +gTypeHTMLBodyElement = + {# call fun unsafe webkit_dom_html_body_element_get_type #} + +-- ********************************************************** HTMLButtonElement + +{#pointer *WebKitDOMHTMLButtonElement as HTMLButtonElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLButtonElement = (HTMLButtonElement, objectUnrefFromMainloop) +unHTMLButtonElement (HTMLButtonElement o) = o + +class HTMLElementClass o => HTMLButtonElementClass o +toHTMLButtonElement :: HTMLButtonElementClass o => o -> HTMLButtonElement +toHTMLButtonElement = unsafeCastGObject . toGObject + +instance HTMLButtonElementClass HTMLButtonElement +instance HTMLElementClass HTMLButtonElement +instance ElementClass HTMLButtonElement +instance NodeClass HTMLButtonElement +instance EventTargetClass HTMLButtonElement +instance GObjectClass HTMLButtonElement where + toGObject = GObject . castForeignPtr . unHTMLButtonElement + unsafeCastGObject = HTMLButtonElement . castForeignPtr . unGObject + +castToHTMLButtonElement :: GObjectClass obj => obj -> HTMLButtonElement +castToHTMLButtonElement = castTo gTypeHTMLButtonElement "HTMLButtonElement" + +gTypeHTMLButtonElement :: GType +gTypeHTMLButtonElement = + {# call fun unsafe webkit_dom_html_button_element_get_type #} + +-- ********************************************************** HTMLCanvasElement + +{#pointer *WebKitDOMHTMLCanvasElement as HTMLCanvasElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLCanvasElement = (HTMLCanvasElement, objectUnrefFromMainloop) +unHTMLCanvasElement (HTMLCanvasElement o) = o + +class HTMLElementClass o => HTMLCanvasElementClass o +toHTMLCanvasElement :: HTMLCanvasElementClass o => o -> HTMLCanvasElement +toHTMLCanvasElement = unsafeCastGObject . toGObject + +instance HTMLCanvasElementClass HTMLCanvasElement +instance HTMLElementClass HTMLCanvasElement +instance ElementClass HTMLCanvasElement +instance NodeClass HTMLCanvasElement +instance EventTargetClass HTMLCanvasElement +instance GObjectClass HTMLCanvasElement where + toGObject = GObject . castForeignPtr . unHTMLCanvasElement + unsafeCastGObject = HTMLCanvasElement . castForeignPtr . unGObject + +castToHTMLCanvasElement :: GObjectClass obj => obj -> HTMLCanvasElement +castToHTMLCanvasElement = castTo gTypeHTMLCanvasElement "HTMLCanvasElement" + +gTypeHTMLCanvasElement :: GType +gTypeHTMLCanvasElement = + {# call fun unsafe webkit_dom_html_canvas_element_get_type #} + +-- *********************************************************** HTMLDListElement + +{#pointer *WebKitDOMHTMLDListElement as HTMLDListElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLDListElement = (HTMLDListElement, objectUnrefFromMainloop) +unHTMLDListElement (HTMLDListElement o) = o + +class HTMLElementClass o => HTMLDListElementClass o +toHTMLDListElement :: HTMLDListElementClass o => o -> HTMLDListElement +toHTMLDListElement = unsafeCastGObject . toGObject + +instance HTMLDListElementClass HTMLDListElement +instance HTMLElementClass HTMLDListElement +instance ElementClass HTMLDListElement +instance NodeClass HTMLDListElement +instance EventTargetClass HTMLDListElement +instance GObjectClass HTMLDListElement where + toGObject = GObject . castForeignPtr . unHTMLDListElement + unsafeCastGObject = HTMLDListElement . castForeignPtr . unGObject + +castToHTMLDListElement :: GObjectClass obj => obj -> HTMLDListElement +castToHTMLDListElement = castTo gTypeHTMLDListElement "HTMLDListElement" + +gTypeHTMLDListElement :: GType +gTypeHTMLDListElement = + {# call fun unsafe webkit_dom_htmld_list_element_get_type #} + +-- ********************************************************* HTMLDetailsElement + +{#pointer *WebKitDOMHTMLDetailsElement as HTMLDetailsElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLDetailsElement = (HTMLDetailsElement, objectUnrefFromMainloop) +unHTMLDetailsElement (HTMLDetailsElement o) = o + +class HTMLElementClass o => HTMLDetailsElementClass o +toHTMLDetailsElement :: HTMLDetailsElementClass o => o -> HTMLDetailsElement +toHTMLDetailsElement = unsafeCastGObject . toGObject + +instance HTMLDetailsElementClass HTMLDetailsElement +instance HTMLElementClass HTMLDetailsElement +instance ElementClass HTMLDetailsElement +instance NodeClass HTMLDetailsElement +instance EventTargetClass HTMLDetailsElement +instance GObjectClass HTMLDetailsElement where + toGObject = GObject . castForeignPtr . unHTMLDetailsElement + unsafeCastGObject = HTMLDetailsElement . castForeignPtr . unGObject + +castToHTMLDetailsElement :: GObjectClass obj => obj -> HTMLDetailsElement +castToHTMLDetailsElement = castTo gTypeHTMLDetailsElement "HTMLDetailsElement" + +gTypeHTMLDetailsElement :: GType +gTypeHTMLDetailsElement = + {# call fun unsafe webkit_dom_html_details_element_get_type #} + +-- ******************************************************* HTMLDirectoryElement + +{#pointer *WebKitDOMHTMLDirectoryElement as HTMLDirectoryElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLDirectoryElement = (HTMLDirectoryElement, objectUnrefFromMainloop) +unHTMLDirectoryElement (HTMLDirectoryElement o) = o + +class HTMLElementClass o => HTMLDirectoryElementClass o +toHTMLDirectoryElement :: HTMLDirectoryElementClass o => o -> HTMLDirectoryElement +toHTMLDirectoryElement = unsafeCastGObject . toGObject + +instance HTMLDirectoryElementClass HTMLDirectoryElement +instance HTMLElementClass HTMLDirectoryElement +instance ElementClass HTMLDirectoryElement +instance NodeClass HTMLDirectoryElement +instance EventTargetClass HTMLDirectoryElement +instance GObjectClass HTMLDirectoryElement where + toGObject = GObject . castForeignPtr . unHTMLDirectoryElement + unsafeCastGObject = HTMLDirectoryElement . castForeignPtr . unGObject + +castToHTMLDirectoryElement :: GObjectClass obj => obj -> HTMLDirectoryElement +castToHTMLDirectoryElement = castTo gTypeHTMLDirectoryElement "HTMLDirectoryElement" + +gTypeHTMLDirectoryElement :: GType +gTypeHTMLDirectoryElement = + {# call fun unsafe webkit_dom_html_directory_element_get_type #} + +-- ************************************************************* HTMLDivElement + +{#pointer *WebKitDOMHTMLDivElement as HTMLDivElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLDivElement = (HTMLDivElement, objectUnrefFromMainloop) +unHTMLDivElement (HTMLDivElement o) = o + +class HTMLElementClass o => HTMLDivElementClass o +toHTMLDivElement :: HTMLDivElementClass o => o -> HTMLDivElement +toHTMLDivElement = unsafeCastGObject . toGObject + +instance HTMLDivElementClass HTMLDivElement +instance HTMLElementClass HTMLDivElement +instance ElementClass HTMLDivElement +instance NodeClass HTMLDivElement +instance EventTargetClass HTMLDivElement +instance GObjectClass HTMLDivElement where + toGObject = GObject . castForeignPtr . unHTMLDivElement + unsafeCastGObject = HTMLDivElement . castForeignPtr . unGObject + +castToHTMLDivElement :: GObjectClass obj => obj -> HTMLDivElement +castToHTMLDivElement = castTo gTypeHTMLDivElement "HTMLDivElement" + +gTypeHTMLDivElement :: GType +gTypeHTMLDivElement = + {# call fun unsafe webkit_dom_html_div_element_get_type #} + +-- *********************************************************** HTMLEmbedElement + +{#pointer *WebKitDOMHTMLEmbedElement as HTMLEmbedElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLEmbedElement = (HTMLEmbedElement, objectUnrefFromMainloop) +unHTMLEmbedElement (HTMLEmbedElement o) = o + +class HTMLElementClass o => HTMLEmbedElementClass o +toHTMLEmbedElement :: HTMLEmbedElementClass o => o -> HTMLEmbedElement +toHTMLEmbedElement = unsafeCastGObject . toGObject + +instance HTMLEmbedElementClass HTMLEmbedElement +instance HTMLElementClass HTMLEmbedElement +instance ElementClass HTMLEmbedElement +instance NodeClass HTMLEmbedElement +instance EventTargetClass HTMLEmbedElement +instance GObjectClass HTMLEmbedElement where + toGObject = GObject . castForeignPtr . unHTMLEmbedElement + unsafeCastGObject = HTMLEmbedElement . castForeignPtr . unGObject + +castToHTMLEmbedElement :: GObjectClass obj => obj -> HTMLEmbedElement +castToHTMLEmbedElement = castTo gTypeHTMLEmbedElement "HTMLEmbedElement" + +gTypeHTMLEmbedElement :: GType +gTypeHTMLEmbedElement = + {# call fun unsafe webkit_dom_html_embed_element_get_type #} + +-- ******************************************************** HTMLFieldSetElement + +{#pointer *WebKitDOMHTMLFieldSetElement as HTMLFieldSetElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLFieldSetElement = (HTMLFieldSetElement, objectUnrefFromMainloop) +unHTMLFieldSetElement (HTMLFieldSetElement o) = o + +class HTMLElementClass o => HTMLFieldSetElementClass o +toHTMLFieldSetElement :: HTMLFieldSetElementClass o => o -> HTMLFieldSetElement +toHTMLFieldSetElement = unsafeCastGObject . toGObject + +instance HTMLFieldSetElementClass HTMLFieldSetElement +instance HTMLElementClass HTMLFieldSetElement +instance ElementClass HTMLFieldSetElement +instance NodeClass HTMLFieldSetElement +instance EventTargetClass HTMLFieldSetElement +instance GObjectClass HTMLFieldSetElement where + toGObject = GObject . castForeignPtr . unHTMLFieldSetElement + unsafeCastGObject = HTMLFieldSetElement . castForeignPtr . unGObject + +castToHTMLFieldSetElement :: GObjectClass obj => obj -> HTMLFieldSetElement +castToHTMLFieldSetElement = castTo gTypeHTMLFieldSetElement "HTMLFieldSetElement" + +gTypeHTMLFieldSetElement :: GType +gTypeHTMLFieldSetElement = + {# call fun unsafe webkit_dom_html_field_set_element_get_type #} + +-- ************************************************************ HTMLFontElement + +{#pointer *WebKitDOMHTMLFontElement as HTMLFontElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLFontElement = (HTMLFontElement, objectUnrefFromMainloop) +unHTMLFontElement (HTMLFontElement o) = o + +class HTMLElementClass o => HTMLFontElementClass o +toHTMLFontElement :: HTMLFontElementClass o => o -> HTMLFontElement +toHTMLFontElement = unsafeCastGObject . toGObject + +instance HTMLFontElementClass HTMLFontElement +instance HTMLElementClass HTMLFontElement +instance ElementClass HTMLFontElement +instance NodeClass HTMLFontElement +instance EventTargetClass HTMLFontElement +instance GObjectClass HTMLFontElement where + toGObject = GObject . castForeignPtr . unHTMLFontElement + unsafeCastGObject = HTMLFontElement . castForeignPtr . unGObject + +castToHTMLFontElement :: GObjectClass obj => obj -> HTMLFontElement +castToHTMLFontElement = castTo gTypeHTMLFontElement "HTMLFontElement" + +gTypeHTMLFontElement :: GType +gTypeHTMLFontElement = + {# call fun unsafe webkit_dom_html_font_element_get_type #} + +-- ************************************************************ HTMLFormElement + +{#pointer *WebKitDOMHTMLFormElement as HTMLFormElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLFormElement = (HTMLFormElement, objectUnrefFromMainloop) +unHTMLFormElement (HTMLFormElement o) = o + +class HTMLElementClass o => HTMLFormElementClass o +toHTMLFormElement :: HTMLFormElementClass o => o -> HTMLFormElement +toHTMLFormElement = unsafeCastGObject . toGObject + +instance HTMLFormElementClass HTMLFormElement +instance HTMLElementClass HTMLFormElement +instance ElementClass HTMLFormElement +instance NodeClass HTMLFormElement +instance EventTargetClass HTMLFormElement +instance GObjectClass HTMLFormElement where + toGObject = GObject . castForeignPtr . unHTMLFormElement + unsafeCastGObject = HTMLFormElement . castForeignPtr . unGObject + +castToHTMLFormElement :: GObjectClass obj => obj -> HTMLFormElement +castToHTMLFormElement = castTo gTypeHTMLFormElement "HTMLFormElement" + +gTypeHTMLFormElement :: GType +gTypeHTMLFormElement = + {# call fun unsafe webkit_dom_html_form_element_get_type #} + +-- *********************************************************** HTMLFrameElement + +{#pointer *WebKitDOMHTMLFrameElement as HTMLFrameElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLFrameElement = (HTMLFrameElement, objectUnrefFromMainloop) +unHTMLFrameElement (HTMLFrameElement o) = o + +class HTMLElementClass o => HTMLFrameElementClass o +toHTMLFrameElement :: HTMLFrameElementClass o => o -> HTMLFrameElement +toHTMLFrameElement = unsafeCastGObject . toGObject + +instance HTMLFrameElementClass HTMLFrameElement +instance HTMLElementClass HTMLFrameElement +instance ElementClass HTMLFrameElement +instance NodeClass HTMLFrameElement +instance EventTargetClass HTMLFrameElement +instance GObjectClass HTMLFrameElement where + toGObject = GObject . castForeignPtr . unHTMLFrameElement + unsafeCastGObject = HTMLFrameElement . castForeignPtr . unGObject + +castToHTMLFrameElement :: GObjectClass obj => obj -> HTMLFrameElement +castToHTMLFrameElement = castTo gTypeHTMLFrameElement "HTMLFrameElement" + +gTypeHTMLFrameElement :: GType +gTypeHTMLFrameElement = + {# call fun unsafe webkit_dom_html_frame_element_get_type #} + +-- ******************************************************** HTMLFrameSetElement + +{#pointer *WebKitDOMHTMLFrameSetElement as HTMLFrameSetElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLFrameSetElement = (HTMLFrameSetElement, objectUnrefFromMainloop) +unHTMLFrameSetElement (HTMLFrameSetElement o) = o + +class HTMLElementClass o => HTMLFrameSetElementClass o +toHTMLFrameSetElement :: HTMLFrameSetElementClass o => o -> HTMLFrameSetElement +toHTMLFrameSetElement = unsafeCastGObject . toGObject + +instance HTMLFrameSetElementClass HTMLFrameSetElement +instance HTMLElementClass HTMLFrameSetElement +instance ElementClass HTMLFrameSetElement +instance NodeClass HTMLFrameSetElement +instance EventTargetClass HTMLFrameSetElement +instance GObjectClass HTMLFrameSetElement where + toGObject = GObject . castForeignPtr . unHTMLFrameSetElement + unsafeCastGObject = HTMLFrameSetElement . castForeignPtr . unGObject + +castToHTMLFrameSetElement :: GObjectClass obj => obj -> HTMLFrameSetElement +castToHTMLFrameSetElement = castTo gTypeHTMLFrameSetElement "HTMLFrameSetElement" + +gTypeHTMLFrameSetElement :: GType +gTypeHTMLFrameSetElement = + {# call fun unsafe webkit_dom_html_frame_set_element_get_type #} + +-- ************************************************************** HTMLHRElement + +{#pointer *WebKitDOMHTMLHRElement as HTMLHRElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLHRElement = (HTMLHRElement, objectUnrefFromMainloop) +unHTMLHRElement (HTMLHRElement o) = o + +class HTMLElementClass o => HTMLHRElementClass o +toHTMLHRElement :: HTMLHRElementClass o => o -> HTMLHRElement +toHTMLHRElement = unsafeCastGObject . toGObject + +instance HTMLHRElementClass HTMLHRElement +instance HTMLElementClass HTMLHRElement +instance ElementClass HTMLHRElement +instance NodeClass HTMLHRElement +instance EventTargetClass HTMLHRElement +instance GObjectClass HTMLHRElement where + toGObject = GObject . castForeignPtr . unHTMLHRElement + unsafeCastGObject = HTMLHRElement . castForeignPtr . unGObject + +castToHTMLHRElement :: GObjectClass obj => obj -> HTMLHRElement +castToHTMLHRElement = castTo gTypeHTMLHRElement "HTMLHRElement" + +gTypeHTMLHRElement :: GType +gTypeHTMLHRElement = + {# call fun unsafe webkit_dom_htmlhr_element_get_type #} + +-- ************************************************************ HTMLHeadElement + +{#pointer *WebKitDOMHTMLHeadElement as HTMLHeadElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLHeadElement = (HTMLHeadElement, objectUnrefFromMainloop) +unHTMLHeadElement (HTMLHeadElement o) = o + +class HTMLElementClass o => HTMLHeadElementClass o +toHTMLHeadElement :: HTMLHeadElementClass o => o -> HTMLHeadElement +toHTMLHeadElement = unsafeCastGObject . toGObject + +instance HTMLHeadElementClass HTMLHeadElement +instance HTMLElementClass HTMLHeadElement +instance ElementClass HTMLHeadElement +instance NodeClass HTMLHeadElement +instance EventTargetClass HTMLHeadElement +instance GObjectClass HTMLHeadElement where + toGObject = GObject . castForeignPtr . unHTMLHeadElement + unsafeCastGObject = HTMLHeadElement . castForeignPtr . unGObject + +castToHTMLHeadElement :: GObjectClass obj => obj -> HTMLHeadElement +castToHTMLHeadElement = castTo gTypeHTMLHeadElement "HTMLHeadElement" + +gTypeHTMLHeadElement :: GType +gTypeHTMLHeadElement = + {# call fun unsafe webkit_dom_html_head_element_get_type #} + +-- ********************************************************* HTMLHeadingElement + +{#pointer *WebKitDOMHTMLHeadingElement as HTMLHeadingElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLHeadingElement = (HTMLHeadingElement, objectUnrefFromMainloop) +unHTMLHeadingElement (HTMLHeadingElement o) = o + +class HTMLElementClass o => HTMLHeadingElementClass o +toHTMLHeadingElement :: HTMLHeadingElementClass o => o -> HTMLHeadingElement +toHTMLHeadingElement = unsafeCastGObject . toGObject + +instance HTMLHeadingElementClass HTMLHeadingElement +instance HTMLElementClass HTMLHeadingElement +instance ElementClass HTMLHeadingElement +instance NodeClass HTMLHeadingElement +instance EventTargetClass HTMLHeadingElement +instance GObjectClass HTMLHeadingElement where + toGObject = GObject . castForeignPtr . unHTMLHeadingElement + unsafeCastGObject = HTMLHeadingElement . castForeignPtr . unGObject + +castToHTMLHeadingElement :: GObjectClass obj => obj -> HTMLHeadingElement +castToHTMLHeadingElement = castTo gTypeHTMLHeadingElement "HTMLHeadingElement" + +gTypeHTMLHeadingElement :: GType +gTypeHTMLHeadingElement = + {# call fun unsafe webkit_dom_html_heading_element_get_type #} + +-- ************************************************************ HTMLHtmlElement + +{#pointer *WebKitDOMHTMLHtmlElement as HTMLHtmlElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLHtmlElement = (HTMLHtmlElement, objectUnrefFromMainloop) +unHTMLHtmlElement (HTMLHtmlElement o) = o + +class HTMLElementClass o => HTMLHtmlElementClass o +toHTMLHtmlElement :: HTMLHtmlElementClass o => o -> HTMLHtmlElement +toHTMLHtmlElement = unsafeCastGObject . toGObject + +instance HTMLHtmlElementClass HTMLHtmlElement +instance HTMLElementClass HTMLHtmlElement +instance ElementClass HTMLHtmlElement +instance NodeClass HTMLHtmlElement +instance EventTargetClass HTMLHtmlElement +instance GObjectClass HTMLHtmlElement where + toGObject = GObject . castForeignPtr . unHTMLHtmlElement + unsafeCastGObject = HTMLHtmlElement . castForeignPtr . unGObject + +castToHTMLHtmlElement :: GObjectClass obj => obj -> HTMLHtmlElement +castToHTMLHtmlElement = castTo gTypeHTMLHtmlElement "HTMLHtmlElement" + +gTypeHTMLHtmlElement :: GType +gTypeHTMLHtmlElement = + {# call fun unsafe webkit_dom_html_html_element_get_type #} + +-- ********************************************************** HTMLIFrameElement + +{#pointer *WebKitDOMHTMLIFrameElement as HTMLIFrameElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLIFrameElement = (HTMLIFrameElement, objectUnrefFromMainloop) +unHTMLIFrameElement (HTMLIFrameElement o) = o + +class HTMLElementClass o => HTMLIFrameElementClass o +toHTMLIFrameElement :: HTMLIFrameElementClass o => o -> HTMLIFrameElement +toHTMLIFrameElement = unsafeCastGObject . toGObject + +instance HTMLIFrameElementClass HTMLIFrameElement +instance HTMLElementClass HTMLIFrameElement +instance ElementClass HTMLIFrameElement +instance NodeClass HTMLIFrameElement +instance EventTargetClass HTMLIFrameElement +instance GObjectClass HTMLIFrameElement where + toGObject = GObject . castForeignPtr . unHTMLIFrameElement + unsafeCastGObject = HTMLIFrameElement . castForeignPtr . unGObject + +castToHTMLIFrameElement :: GObjectClass obj => obj -> HTMLIFrameElement +castToHTMLIFrameElement = castTo gTypeHTMLIFrameElement "HTMLIFrameElement" + +gTypeHTMLIFrameElement :: GType +gTypeHTMLIFrameElement = + {# call fun unsafe webkit_dom_html_iframe_element_get_type #} + +-- *********************************************************** HTMLImageElement + +{#pointer *WebKitDOMHTMLImageElement as HTMLImageElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLImageElement = (HTMLImageElement, objectUnrefFromMainloop) +unHTMLImageElement (HTMLImageElement o) = o + +class HTMLElementClass o => HTMLImageElementClass o +toHTMLImageElement :: HTMLImageElementClass o => o -> HTMLImageElement +toHTMLImageElement = unsafeCastGObject . toGObject + +instance HTMLImageElementClass HTMLImageElement +instance HTMLElementClass HTMLImageElement +instance ElementClass HTMLImageElement +instance NodeClass HTMLImageElement +instance EventTargetClass HTMLImageElement +instance GObjectClass HTMLImageElement where + toGObject = GObject . castForeignPtr . unHTMLImageElement + unsafeCastGObject = HTMLImageElement . castForeignPtr . unGObject + +castToHTMLImageElement :: GObjectClass obj => obj -> HTMLImageElement +castToHTMLImageElement = castTo gTypeHTMLImageElement "HTMLImageElement" + +gTypeHTMLImageElement :: GType +gTypeHTMLImageElement = + {# call fun unsafe webkit_dom_html_image_element_get_type #} + +-- *********************************************************** HTMLInputElement + +{#pointer *WebKitDOMHTMLInputElement as HTMLInputElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLInputElement = (HTMLInputElement, objectUnrefFromMainloop) +unHTMLInputElement (HTMLInputElement o) = o + +class HTMLElementClass o => HTMLInputElementClass o +toHTMLInputElement :: HTMLInputElementClass o => o -> HTMLInputElement +toHTMLInputElement = unsafeCastGObject . toGObject + +instance HTMLInputElementClass HTMLInputElement +instance HTMLElementClass HTMLInputElement +instance ElementClass HTMLInputElement +instance NodeClass HTMLInputElement +instance EventTargetClass HTMLInputElement +instance GObjectClass HTMLInputElement where + toGObject = GObject . castForeignPtr . unHTMLInputElement + unsafeCastGObject = HTMLInputElement . castForeignPtr . unGObject + +castToHTMLInputElement :: GObjectClass obj => obj -> HTMLInputElement +castToHTMLInputElement = castTo gTypeHTMLInputElement "HTMLInputElement" + +gTypeHTMLInputElement :: GType +gTypeHTMLInputElement = + {# call fun unsafe webkit_dom_html_input_element_get_type #} + +-- ********************************************************** HTMLKeygenElement + +{#pointer *WebKitDOMHTMLKeygenElement as HTMLKeygenElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLKeygenElement = (HTMLKeygenElement, objectUnrefFromMainloop) +unHTMLKeygenElement (HTMLKeygenElement o) = o + +class HTMLElementClass o => HTMLKeygenElementClass o +toHTMLKeygenElement :: HTMLKeygenElementClass o => o -> HTMLKeygenElement +toHTMLKeygenElement = unsafeCastGObject . toGObject + +instance HTMLKeygenElementClass HTMLKeygenElement +instance HTMLElementClass HTMLKeygenElement +instance ElementClass HTMLKeygenElement +instance NodeClass HTMLKeygenElement +instance EventTargetClass HTMLKeygenElement +instance GObjectClass HTMLKeygenElement where + toGObject = GObject . castForeignPtr . unHTMLKeygenElement + unsafeCastGObject = HTMLKeygenElement . castForeignPtr . unGObject + +castToHTMLKeygenElement :: GObjectClass obj => obj -> HTMLKeygenElement +castToHTMLKeygenElement = castTo gTypeHTMLKeygenElement "HTMLKeygenElement" + +gTypeHTMLKeygenElement :: GType +gTypeHTMLKeygenElement = + {# call fun unsafe webkit_dom_html_keygen_element_get_type #} + +-- ************************************************************** HTMLLIElement + +{#pointer *WebKitDOMHTMLLIElement as HTMLLIElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLLIElement = (HTMLLIElement, objectUnrefFromMainloop) +unHTMLLIElement (HTMLLIElement o) = o + +class HTMLElementClass o => HTMLLIElementClass o +toHTMLLIElement :: HTMLLIElementClass o => o -> HTMLLIElement +toHTMLLIElement = unsafeCastGObject . toGObject + +instance HTMLLIElementClass HTMLLIElement +instance HTMLElementClass HTMLLIElement +instance ElementClass HTMLLIElement +instance NodeClass HTMLLIElement +instance EventTargetClass HTMLLIElement +instance GObjectClass HTMLLIElement where + toGObject = GObject . castForeignPtr . unHTMLLIElement + unsafeCastGObject = HTMLLIElement . castForeignPtr . unGObject + +castToHTMLLIElement :: GObjectClass obj => obj -> HTMLLIElement +castToHTMLLIElement = castTo gTypeHTMLLIElement "HTMLLIElement" + +gTypeHTMLLIElement :: GType +gTypeHTMLLIElement = + {# call fun unsafe webkit_dom_htmlli_element_get_type #} + +-- *********************************************************** HTMLLabelElement + +{#pointer *WebKitDOMHTMLLabelElement as HTMLLabelElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLLabelElement = (HTMLLabelElement, objectUnrefFromMainloop) +unHTMLLabelElement (HTMLLabelElement o) = o + +class HTMLElementClass o => HTMLLabelElementClass o +toHTMLLabelElement :: HTMLLabelElementClass o => o -> HTMLLabelElement +toHTMLLabelElement = unsafeCastGObject . toGObject + +instance HTMLLabelElementClass HTMLLabelElement +instance HTMLElementClass HTMLLabelElement +instance ElementClass HTMLLabelElement +instance NodeClass HTMLLabelElement +instance EventTargetClass HTMLLabelElement +instance GObjectClass HTMLLabelElement where + toGObject = GObject . castForeignPtr . unHTMLLabelElement + unsafeCastGObject = HTMLLabelElement . castForeignPtr . unGObject + +castToHTMLLabelElement :: GObjectClass obj => obj -> HTMLLabelElement +castToHTMLLabelElement = castTo gTypeHTMLLabelElement "HTMLLabelElement" + +gTypeHTMLLabelElement :: GType +gTypeHTMLLabelElement = + {# call fun unsafe webkit_dom_html_label_element_get_type #} + +-- ********************************************************** HTMLLegendElement + +{#pointer *WebKitDOMHTMLLegendElement as HTMLLegendElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLLegendElement = (HTMLLegendElement, objectUnrefFromMainloop) +unHTMLLegendElement (HTMLLegendElement o) = o + +class HTMLElementClass o => HTMLLegendElementClass o +toHTMLLegendElement :: HTMLLegendElementClass o => o -> HTMLLegendElement +toHTMLLegendElement = unsafeCastGObject . toGObject + +instance HTMLLegendElementClass HTMLLegendElement +instance HTMLElementClass HTMLLegendElement +instance ElementClass HTMLLegendElement +instance NodeClass HTMLLegendElement +instance EventTargetClass HTMLLegendElement +instance GObjectClass HTMLLegendElement where + toGObject = GObject . castForeignPtr . unHTMLLegendElement + unsafeCastGObject = HTMLLegendElement . castForeignPtr . unGObject + +castToHTMLLegendElement :: GObjectClass obj => obj -> HTMLLegendElement +castToHTMLLegendElement = castTo gTypeHTMLLegendElement "HTMLLegendElement" + +gTypeHTMLLegendElement :: GType +gTypeHTMLLegendElement = + {# call fun unsafe webkit_dom_html_legend_element_get_type #} + +-- ************************************************************ HTMLLinkElement + +{#pointer *WebKitDOMHTMLLinkElement as HTMLLinkElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLLinkElement = (HTMLLinkElement, objectUnrefFromMainloop) +unHTMLLinkElement (HTMLLinkElement o) = o + +class HTMLElementClass o => HTMLLinkElementClass o +toHTMLLinkElement :: HTMLLinkElementClass o => o -> HTMLLinkElement +toHTMLLinkElement = unsafeCastGObject . toGObject + +instance HTMLLinkElementClass HTMLLinkElement +instance HTMLElementClass HTMLLinkElement +instance ElementClass HTMLLinkElement +instance NodeClass HTMLLinkElement +instance EventTargetClass HTMLLinkElement +instance GObjectClass HTMLLinkElement where + toGObject = GObject . castForeignPtr . unHTMLLinkElement + unsafeCastGObject = HTMLLinkElement . castForeignPtr . unGObject + +castToHTMLLinkElement :: GObjectClass obj => obj -> HTMLLinkElement +castToHTMLLinkElement = castTo gTypeHTMLLinkElement "HTMLLinkElement" + +gTypeHTMLLinkElement :: GType +gTypeHTMLLinkElement = + {# call fun unsafe webkit_dom_html_link_element_get_type #} + +-- ************************************************************* HTMLMapElement + +{#pointer *WebKitDOMHTMLMapElement as HTMLMapElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLMapElement = (HTMLMapElement, objectUnrefFromMainloop) +unHTMLMapElement (HTMLMapElement o) = o + +class HTMLElementClass o => HTMLMapElementClass o +toHTMLMapElement :: HTMLMapElementClass o => o -> HTMLMapElement +toHTMLMapElement = unsafeCastGObject . toGObject + +instance HTMLMapElementClass HTMLMapElement +instance HTMLElementClass HTMLMapElement +instance ElementClass HTMLMapElement +instance NodeClass HTMLMapElement +instance EventTargetClass HTMLMapElement +instance GObjectClass HTMLMapElement where + toGObject = GObject . castForeignPtr . unHTMLMapElement + unsafeCastGObject = HTMLMapElement . castForeignPtr . unGObject + +castToHTMLMapElement :: GObjectClass obj => obj -> HTMLMapElement +castToHTMLMapElement = castTo gTypeHTMLMapElement "HTMLMapElement" + +gTypeHTMLMapElement :: GType +gTypeHTMLMapElement = + {# call fun unsafe webkit_dom_html_map_element_get_type #} + +-- ********************************************************* HTMLMarqueeElement + +{#pointer *WebKitDOMHTMLMarqueeElement as HTMLMarqueeElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLMarqueeElement = (HTMLMarqueeElement, objectUnrefFromMainloop) +unHTMLMarqueeElement (HTMLMarqueeElement o) = o + +class HTMLElementClass o => HTMLMarqueeElementClass o +toHTMLMarqueeElement :: HTMLMarqueeElementClass o => o -> HTMLMarqueeElement +toHTMLMarqueeElement = unsafeCastGObject . toGObject + +instance HTMLMarqueeElementClass HTMLMarqueeElement +instance HTMLElementClass HTMLMarqueeElement +instance ElementClass HTMLMarqueeElement +instance NodeClass HTMLMarqueeElement +instance EventTargetClass HTMLMarqueeElement +instance GObjectClass HTMLMarqueeElement where + toGObject = GObject . castForeignPtr . unHTMLMarqueeElement + unsafeCastGObject = HTMLMarqueeElement . castForeignPtr . unGObject + +castToHTMLMarqueeElement :: GObjectClass obj => obj -> HTMLMarqueeElement +castToHTMLMarqueeElement = castTo gTypeHTMLMarqueeElement "HTMLMarqueeElement" + +gTypeHTMLMarqueeElement :: GType +gTypeHTMLMarqueeElement = + {# call fun unsafe webkit_dom_html_marquee_element_get_type #} + +-- ************************************************************ HTMLMenuElement + +{#pointer *WebKitDOMHTMLMenuElement as HTMLMenuElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLMenuElement = (HTMLMenuElement, objectUnrefFromMainloop) +unHTMLMenuElement (HTMLMenuElement o) = o + +class HTMLElementClass o => HTMLMenuElementClass o +toHTMLMenuElement :: HTMLMenuElementClass o => o -> HTMLMenuElement +toHTMLMenuElement = unsafeCastGObject . toGObject + +instance HTMLMenuElementClass HTMLMenuElement +instance HTMLElementClass HTMLMenuElement +instance ElementClass HTMLMenuElement +instance NodeClass HTMLMenuElement +instance EventTargetClass HTMLMenuElement +instance GObjectClass HTMLMenuElement where + toGObject = GObject . castForeignPtr . unHTMLMenuElement + unsafeCastGObject = HTMLMenuElement . castForeignPtr . unGObject + +castToHTMLMenuElement :: GObjectClass obj => obj -> HTMLMenuElement +castToHTMLMenuElement = castTo gTypeHTMLMenuElement "HTMLMenuElement" + +gTypeHTMLMenuElement :: GType +gTypeHTMLMenuElement = + {# call fun unsafe webkit_dom_html_menu_element_get_type #} + +-- ************************************************************ HTMLMetaElement + +{#pointer *WebKitDOMHTMLMetaElement as HTMLMetaElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLMetaElement = (HTMLMetaElement, objectUnrefFromMainloop) +unHTMLMetaElement (HTMLMetaElement o) = o + +class HTMLElementClass o => HTMLMetaElementClass o +toHTMLMetaElement :: HTMLMetaElementClass o => o -> HTMLMetaElement +toHTMLMetaElement = unsafeCastGObject . toGObject + +instance HTMLMetaElementClass HTMLMetaElement +instance HTMLElementClass HTMLMetaElement +instance ElementClass HTMLMetaElement +instance NodeClass HTMLMetaElement +instance EventTargetClass HTMLMetaElement +instance GObjectClass HTMLMetaElement where + toGObject = GObject . castForeignPtr . unHTMLMetaElement + unsafeCastGObject = HTMLMetaElement . castForeignPtr . unGObject + +castToHTMLMetaElement :: GObjectClass obj => obj -> HTMLMetaElement +castToHTMLMetaElement = castTo gTypeHTMLMetaElement "HTMLMetaElement" + +gTypeHTMLMetaElement :: GType +gTypeHTMLMetaElement = + {# call fun unsafe webkit_dom_html_meta_element_get_type #} + +-- ************************************************************* HTMLModElement + +{#pointer *WebKitDOMHTMLModElement as HTMLModElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLModElement = (HTMLModElement, objectUnrefFromMainloop) +unHTMLModElement (HTMLModElement o) = o + +class HTMLElementClass o => HTMLModElementClass o +toHTMLModElement :: HTMLModElementClass o => o -> HTMLModElement +toHTMLModElement = unsafeCastGObject . toGObject + +instance HTMLModElementClass HTMLModElement +instance HTMLElementClass HTMLModElement +instance ElementClass HTMLModElement +instance NodeClass HTMLModElement +instance EventTargetClass HTMLModElement +instance GObjectClass HTMLModElement where + toGObject = GObject . castForeignPtr . unHTMLModElement + unsafeCastGObject = HTMLModElement . castForeignPtr . unGObject + +castToHTMLModElement :: GObjectClass obj => obj -> HTMLModElement +castToHTMLModElement = castTo gTypeHTMLModElement "HTMLModElement" + +gTypeHTMLModElement :: GType +gTypeHTMLModElement = + {# call fun unsafe webkit_dom_html_mod_element_get_type #} + +-- *********************************************************** HTMLOListElement + +{#pointer *WebKitDOMHTMLOListElement as HTMLOListElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLOListElement = (HTMLOListElement, objectUnrefFromMainloop) +unHTMLOListElement (HTMLOListElement o) = o + +class HTMLElementClass o => HTMLOListElementClass o +toHTMLOListElement :: HTMLOListElementClass o => o -> HTMLOListElement +toHTMLOListElement = unsafeCastGObject . toGObject + +instance HTMLOListElementClass HTMLOListElement +instance HTMLElementClass HTMLOListElement +instance ElementClass HTMLOListElement +instance NodeClass HTMLOListElement +instance EventTargetClass HTMLOListElement +instance GObjectClass HTMLOListElement where + toGObject = GObject . castForeignPtr . unHTMLOListElement + unsafeCastGObject = HTMLOListElement . castForeignPtr . unGObject + +castToHTMLOListElement :: GObjectClass obj => obj -> HTMLOListElement +castToHTMLOListElement = castTo gTypeHTMLOListElement "HTMLOListElement" + +gTypeHTMLOListElement :: GType +gTypeHTMLOListElement = + {# call fun unsafe webkit_dom_htmlo_list_element_get_type #} + +-- ********************************************************** HTMLObjectElement + +{#pointer *WebKitDOMHTMLObjectElement as HTMLObjectElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLObjectElement = (HTMLObjectElement, objectUnrefFromMainloop) +unHTMLObjectElement (HTMLObjectElement o) = o + +class HTMLElementClass o => HTMLObjectElementClass o +toHTMLObjectElement :: HTMLObjectElementClass o => o -> HTMLObjectElement +toHTMLObjectElement = unsafeCastGObject . toGObject + +instance HTMLObjectElementClass HTMLObjectElement +instance HTMLElementClass HTMLObjectElement +instance ElementClass HTMLObjectElement +instance NodeClass HTMLObjectElement +instance EventTargetClass HTMLObjectElement +instance GObjectClass HTMLObjectElement where + toGObject = GObject . castForeignPtr . unHTMLObjectElement + unsafeCastGObject = HTMLObjectElement . castForeignPtr . unGObject + +castToHTMLObjectElement :: GObjectClass obj => obj -> HTMLObjectElement +castToHTMLObjectElement = castTo gTypeHTMLObjectElement "HTMLObjectElement" + +gTypeHTMLObjectElement :: GType +gTypeHTMLObjectElement = + {# call fun unsafe webkit_dom_html_object_element_get_type #} + +-- ******************************************************** HTMLOptGroupElement + +{#pointer *WebKitDOMHTMLOptGroupElement as HTMLOptGroupElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLOptGroupElement = (HTMLOptGroupElement, objectUnrefFromMainloop) +unHTMLOptGroupElement (HTMLOptGroupElement o) = o + +class HTMLElementClass o => HTMLOptGroupElementClass o +toHTMLOptGroupElement :: HTMLOptGroupElementClass o => o -> HTMLOptGroupElement +toHTMLOptGroupElement = unsafeCastGObject . toGObject + +instance HTMLOptGroupElementClass HTMLOptGroupElement +instance HTMLElementClass HTMLOptGroupElement +instance ElementClass HTMLOptGroupElement +instance NodeClass HTMLOptGroupElement +instance EventTargetClass HTMLOptGroupElement +instance GObjectClass HTMLOptGroupElement where + toGObject = GObject . castForeignPtr . unHTMLOptGroupElement + unsafeCastGObject = HTMLOptGroupElement . castForeignPtr . unGObject + +castToHTMLOptGroupElement :: GObjectClass obj => obj -> HTMLOptGroupElement +castToHTMLOptGroupElement = castTo gTypeHTMLOptGroupElement "HTMLOptGroupElement" + +gTypeHTMLOptGroupElement :: GType +gTypeHTMLOptGroupElement = + {# call fun unsafe webkit_dom_html_opt_group_element_get_type #} + +-- ********************************************************** HTMLOptionElement + +{#pointer *WebKitDOMHTMLOptionElement as HTMLOptionElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLOptionElement = (HTMLOptionElement, objectUnrefFromMainloop) +unHTMLOptionElement (HTMLOptionElement o) = o + +class HTMLElementClass o => HTMLOptionElementClass o +toHTMLOptionElement :: HTMLOptionElementClass o => o -> HTMLOptionElement +toHTMLOptionElement = unsafeCastGObject . toGObject + +instance HTMLOptionElementClass HTMLOptionElement +instance HTMLElementClass HTMLOptionElement +instance ElementClass HTMLOptionElement +instance NodeClass HTMLOptionElement +instance EventTargetClass HTMLOptionElement +instance GObjectClass HTMLOptionElement where + toGObject = GObject . castForeignPtr . unHTMLOptionElement + unsafeCastGObject = HTMLOptionElement . castForeignPtr . unGObject + +castToHTMLOptionElement :: GObjectClass obj => obj -> HTMLOptionElement +castToHTMLOptionElement = castTo gTypeHTMLOptionElement "HTMLOptionElement" + +gTypeHTMLOptionElement :: GType +gTypeHTMLOptionElement = + {# call fun unsafe webkit_dom_html_option_element_get_type #} + +-- ******************************************************* HTMLParagraphElement + +{#pointer *WebKitDOMHTMLParagraphElement as HTMLParagraphElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLParagraphElement = (HTMLParagraphElement, objectUnrefFromMainloop) +unHTMLParagraphElement (HTMLParagraphElement o) = o + +class HTMLElementClass o => HTMLParagraphElementClass o +toHTMLParagraphElement :: HTMLParagraphElementClass o => o -> HTMLParagraphElement +toHTMLParagraphElement = unsafeCastGObject . toGObject + +instance HTMLParagraphElementClass HTMLParagraphElement +instance HTMLElementClass HTMLParagraphElement +instance ElementClass HTMLParagraphElement +instance NodeClass HTMLParagraphElement +instance EventTargetClass HTMLParagraphElement +instance GObjectClass HTMLParagraphElement where + toGObject = GObject . castForeignPtr . unHTMLParagraphElement + unsafeCastGObject = HTMLParagraphElement . castForeignPtr . unGObject + +castToHTMLParagraphElement :: GObjectClass obj => obj -> HTMLParagraphElement +castToHTMLParagraphElement = castTo gTypeHTMLParagraphElement "HTMLParagraphElement" + +gTypeHTMLParagraphElement :: GType +gTypeHTMLParagraphElement = + {# call fun unsafe webkit_dom_html_paragraph_element_get_type #} + +-- *********************************************************** HTMLParamElement + +{#pointer *WebKitDOMHTMLParamElement as HTMLParamElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLParamElement = (HTMLParamElement, objectUnrefFromMainloop) +unHTMLParamElement (HTMLParamElement o) = o + +class HTMLElementClass o => HTMLParamElementClass o +toHTMLParamElement :: HTMLParamElementClass o => o -> HTMLParamElement +toHTMLParamElement = unsafeCastGObject . toGObject + +instance HTMLParamElementClass HTMLParamElement +instance HTMLElementClass HTMLParamElement +instance ElementClass HTMLParamElement +instance NodeClass HTMLParamElement +instance EventTargetClass HTMLParamElement +instance GObjectClass HTMLParamElement where + toGObject = GObject . castForeignPtr . unHTMLParamElement + unsafeCastGObject = HTMLParamElement . castForeignPtr . unGObject + +castToHTMLParamElement :: GObjectClass obj => obj -> HTMLParamElement +castToHTMLParamElement = castTo gTypeHTMLParamElement "HTMLParamElement" + +gTypeHTMLParamElement :: GType +gTypeHTMLParamElement = + {# call fun unsafe webkit_dom_html_param_element_get_type #} + +-- ************************************************************* HTMLPreElement + +{#pointer *WebKitDOMHTMLPreElement as HTMLPreElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLPreElement = (HTMLPreElement, objectUnrefFromMainloop) +unHTMLPreElement (HTMLPreElement o) = o + +class HTMLElementClass o => HTMLPreElementClass o +toHTMLPreElement :: HTMLPreElementClass o => o -> HTMLPreElement +toHTMLPreElement = unsafeCastGObject . toGObject + +instance HTMLPreElementClass HTMLPreElement +instance HTMLElementClass HTMLPreElement +instance ElementClass HTMLPreElement +instance NodeClass HTMLPreElement +instance EventTargetClass HTMLPreElement +instance GObjectClass HTMLPreElement where + toGObject = GObject . castForeignPtr . unHTMLPreElement + unsafeCastGObject = HTMLPreElement . castForeignPtr . unGObject + +castToHTMLPreElement :: GObjectClass obj => obj -> HTMLPreElement +castToHTMLPreElement = castTo gTypeHTMLPreElement "HTMLPreElement" + +gTypeHTMLPreElement :: GType +gTypeHTMLPreElement = + {# call fun unsafe webkit_dom_html_pre_element_get_type #} + +-- *********************************************************** HTMLQuoteElement + +{#pointer *WebKitDOMHTMLQuoteElement as HTMLQuoteElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLQuoteElement = (HTMLQuoteElement, objectUnrefFromMainloop) +unHTMLQuoteElement (HTMLQuoteElement o) = o + +class HTMLElementClass o => HTMLQuoteElementClass o +toHTMLQuoteElement :: HTMLQuoteElementClass o => o -> HTMLQuoteElement +toHTMLQuoteElement = unsafeCastGObject . toGObject + +instance HTMLQuoteElementClass HTMLQuoteElement +instance HTMLElementClass HTMLQuoteElement +instance ElementClass HTMLQuoteElement +instance NodeClass HTMLQuoteElement +instance EventTargetClass HTMLQuoteElement +instance GObjectClass HTMLQuoteElement where + toGObject = GObject . castForeignPtr . unHTMLQuoteElement + unsafeCastGObject = HTMLQuoteElement . castForeignPtr . unGObject + +castToHTMLQuoteElement :: GObjectClass obj => obj -> HTMLQuoteElement +castToHTMLQuoteElement = castTo gTypeHTMLQuoteElement "HTMLQuoteElement" + +gTypeHTMLQuoteElement :: GType +gTypeHTMLQuoteElement = + {# call fun unsafe webkit_dom_html_quote_element_get_type #} + +-- ********************************************************** HTMLScriptElement + +{#pointer *WebKitDOMHTMLScriptElement as HTMLScriptElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLScriptElement = (HTMLScriptElement, objectUnrefFromMainloop) +unHTMLScriptElement (HTMLScriptElement o) = o + +class HTMLElementClass o => HTMLScriptElementClass o +toHTMLScriptElement :: HTMLScriptElementClass o => o -> HTMLScriptElement +toHTMLScriptElement = unsafeCastGObject . toGObject + +instance HTMLScriptElementClass HTMLScriptElement +instance HTMLElementClass HTMLScriptElement +instance ElementClass HTMLScriptElement +instance NodeClass HTMLScriptElement +instance EventTargetClass HTMLScriptElement +instance GObjectClass HTMLScriptElement where + toGObject = GObject . castForeignPtr . unHTMLScriptElement + unsafeCastGObject = HTMLScriptElement . castForeignPtr . unGObject + +castToHTMLScriptElement :: GObjectClass obj => obj -> HTMLScriptElement +castToHTMLScriptElement = castTo gTypeHTMLScriptElement "HTMLScriptElement" + +gTypeHTMLScriptElement :: GType +gTypeHTMLScriptElement = + {# call fun unsafe webkit_dom_html_script_element_get_type #} + +-- ********************************************************** HTMLSelectElement + +{#pointer *WebKitDOMHTMLSelectElement as HTMLSelectElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLSelectElement = (HTMLSelectElement, objectUnrefFromMainloop) +unHTMLSelectElement (HTMLSelectElement o) = o + +class HTMLElementClass o => HTMLSelectElementClass o +toHTMLSelectElement :: HTMLSelectElementClass o => o -> HTMLSelectElement +toHTMLSelectElement = unsafeCastGObject . toGObject + +instance HTMLSelectElementClass HTMLSelectElement +instance HTMLElementClass HTMLSelectElement +instance ElementClass HTMLSelectElement +instance NodeClass HTMLSelectElement +instance EventTargetClass HTMLSelectElement +instance GObjectClass HTMLSelectElement where + toGObject = GObject . castForeignPtr . unHTMLSelectElement + unsafeCastGObject = HTMLSelectElement . castForeignPtr . unGObject + +castToHTMLSelectElement :: GObjectClass obj => obj -> HTMLSelectElement +castToHTMLSelectElement = castTo gTypeHTMLSelectElement "HTMLSelectElement" + +gTypeHTMLSelectElement :: GType +gTypeHTMLSelectElement = + {# call fun unsafe webkit_dom_html_select_element_get_type #} + +-- *********************************************************** HTMLStyleElement + +{#pointer *WebKitDOMHTMLStyleElement as HTMLStyleElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLStyleElement = (HTMLStyleElement, objectUnrefFromMainloop) +unHTMLStyleElement (HTMLStyleElement o) = o + +class HTMLElementClass o => HTMLStyleElementClass o +toHTMLStyleElement :: HTMLStyleElementClass o => o -> HTMLStyleElement +toHTMLStyleElement = unsafeCastGObject . toGObject + +instance HTMLStyleElementClass HTMLStyleElement +instance HTMLElementClass HTMLStyleElement +instance ElementClass HTMLStyleElement +instance NodeClass HTMLStyleElement +instance EventTargetClass HTMLStyleElement +instance GObjectClass HTMLStyleElement where + toGObject = GObject . castForeignPtr . unHTMLStyleElement + unsafeCastGObject = HTMLStyleElement . castForeignPtr . unGObject + +castToHTMLStyleElement :: GObjectClass obj => obj -> HTMLStyleElement +castToHTMLStyleElement = castTo gTypeHTMLStyleElement "HTMLStyleElement" + +gTypeHTMLStyleElement :: GType +gTypeHTMLStyleElement = + {# call fun unsafe webkit_dom_html_style_element_get_type #} + +-- **************************************************** HTMLTableCaptionElement + +{#pointer *WebKitDOMHTMLTableCaptionElement as HTMLTableCaptionElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLTableCaptionElement = (HTMLTableCaptionElement, objectUnrefFromMainloop) +unHTMLTableCaptionElement (HTMLTableCaptionElement o) = o + +class HTMLElementClass o => HTMLTableCaptionElementClass o +toHTMLTableCaptionElement :: HTMLTableCaptionElementClass o => o -> HTMLTableCaptionElement +toHTMLTableCaptionElement = unsafeCastGObject . toGObject + +instance HTMLTableCaptionElementClass HTMLTableCaptionElement +instance HTMLElementClass HTMLTableCaptionElement +instance ElementClass HTMLTableCaptionElement +instance NodeClass HTMLTableCaptionElement +instance EventTargetClass HTMLTableCaptionElement +instance GObjectClass HTMLTableCaptionElement where + toGObject = GObject . castForeignPtr . unHTMLTableCaptionElement + unsafeCastGObject = HTMLTableCaptionElement . castForeignPtr . unGObject + +castToHTMLTableCaptionElement :: GObjectClass obj => obj -> HTMLTableCaptionElement +castToHTMLTableCaptionElement = castTo gTypeHTMLTableCaptionElement "HTMLTableCaptionElement" + +gTypeHTMLTableCaptionElement :: GType +gTypeHTMLTableCaptionElement = + {# call fun unsafe webkit_dom_html_table_caption_element_get_type #} + +-- ******************************************************* HTMLTableCellElement + +{#pointer *WebKitDOMHTMLTableCellElement as HTMLTableCellElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLTableCellElement = (HTMLTableCellElement, objectUnrefFromMainloop) +unHTMLTableCellElement (HTMLTableCellElement o) = o + +class HTMLElementClass o => HTMLTableCellElementClass o +toHTMLTableCellElement :: HTMLTableCellElementClass o => o -> HTMLTableCellElement +toHTMLTableCellElement = unsafeCastGObject . toGObject + +instance HTMLTableCellElementClass HTMLTableCellElement +instance HTMLElementClass HTMLTableCellElement +instance ElementClass HTMLTableCellElement +instance NodeClass HTMLTableCellElement +instance EventTargetClass HTMLTableCellElement +instance GObjectClass HTMLTableCellElement where + toGObject = GObject . castForeignPtr . unHTMLTableCellElement + unsafeCastGObject = HTMLTableCellElement . castForeignPtr . unGObject + +castToHTMLTableCellElement :: GObjectClass obj => obj -> HTMLTableCellElement +castToHTMLTableCellElement = castTo gTypeHTMLTableCellElement "HTMLTableCellElement" + +gTypeHTMLTableCellElement :: GType +gTypeHTMLTableCellElement = + {# call fun unsafe webkit_dom_html_table_cell_element_get_type #} + +-- ******************************************************** HTMLTableColElement + +{#pointer *WebKitDOMHTMLTableColElement as HTMLTableColElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLTableColElement = (HTMLTableColElement, objectUnrefFromMainloop) +unHTMLTableColElement (HTMLTableColElement o) = o + +class HTMLElementClass o => HTMLTableColElementClass o +toHTMLTableColElement :: HTMLTableColElementClass o => o -> HTMLTableColElement +toHTMLTableColElement = unsafeCastGObject . toGObject + +instance HTMLTableColElementClass HTMLTableColElement +instance HTMLElementClass HTMLTableColElement +instance ElementClass HTMLTableColElement +instance NodeClass HTMLTableColElement +instance EventTargetClass HTMLTableColElement +instance GObjectClass HTMLTableColElement where + toGObject = GObject . castForeignPtr . unHTMLTableColElement + unsafeCastGObject = HTMLTableColElement . castForeignPtr . unGObject + +castToHTMLTableColElement :: GObjectClass obj => obj -> HTMLTableColElement +castToHTMLTableColElement = castTo gTypeHTMLTableColElement "HTMLTableColElement" + +gTypeHTMLTableColElement :: GType +gTypeHTMLTableColElement = + {# call fun unsafe webkit_dom_html_table_col_element_get_type #} + +-- *********************************************************** HTMLTableElement + +{#pointer *WebKitDOMHTMLTableElement as HTMLTableElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLTableElement = (HTMLTableElement, objectUnrefFromMainloop) +unHTMLTableElement (HTMLTableElement o) = o + +class HTMLElementClass o => HTMLTableElementClass o +toHTMLTableElement :: HTMLTableElementClass o => o -> HTMLTableElement +toHTMLTableElement = unsafeCastGObject . toGObject + +instance HTMLTableElementClass HTMLTableElement +instance HTMLElementClass HTMLTableElement +instance ElementClass HTMLTableElement +instance NodeClass HTMLTableElement +instance EventTargetClass HTMLTableElement +instance GObjectClass HTMLTableElement where + toGObject = GObject . castForeignPtr . unHTMLTableElement + unsafeCastGObject = HTMLTableElement . castForeignPtr . unGObject + +castToHTMLTableElement :: GObjectClass obj => obj -> HTMLTableElement +castToHTMLTableElement = castTo gTypeHTMLTableElement "HTMLTableElement" + +gTypeHTMLTableElement :: GType +gTypeHTMLTableElement = + {# call fun unsafe webkit_dom_html_table_element_get_type #} + +-- ******************************************************** HTMLTableRowElement + +{#pointer *WebKitDOMHTMLTableRowElement as HTMLTableRowElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLTableRowElement = (HTMLTableRowElement, objectUnrefFromMainloop) +unHTMLTableRowElement (HTMLTableRowElement o) = o + +class HTMLElementClass o => HTMLTableRowElementClass o +toHTMLTableRowElement :: HTMLTableRowElementClass o => o -> HTMLTableRowElement +toHTMLTableRowElement = unsafeCastGObject . toGObject + +instance HTMLTableRowElementClass HTMLTableRowElement +instance HTMLElementClass HTMLTableRowElement +instance ElementClass HTMLTableRowElement +instance NodeClass HTMLTableRowElement +instance EventTargetClass HTMLTableRowElement +instance GObjectClass HTMLTableRowElement where + toGObject = GObject . castForeignPtr . unHTMLTableRowElement + unsafeCastGObject = HTMLTableRowElement . castForeignPtr . unGObject + +castToHTMLTableRowElement :: GObjectClass obj => obj -> HTMLTableRowElement +castToHTMLTableRowElement = castTo gTypeHTMLTableRowElement "HTMLTableRowElement" + +gTypeHTMLTableRowElement :: GType +gTypeHTMLTableRowElement = + {# call fun unsafe webkit_dom_html_table_row_element_get_type #} + +-- **************************************************** HTMLTableSectionElement + +{#pointer *WebKitDOMHTMLTableSectionElement as HTMLTableSectionElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLTableSectionElement = (HTMLTableSectionElement, objectUnrefFromMainloop) +unHTMLTableSectionElement (HTMLTableSectionElement o) = o + +class HTMLElementClass o => HTMLTableSectionElementClass o +toHTMLTableSectionElement :: HTMLTableSectionElementClass o => o -> HTMLTableSectionElement +toHTMLTableSectionElement = unsafeCastGObject . toGObject + +instance HTMLTableSectionElementClass HTMLTableSectionElement +instance HTMLElementClass HTMLTableSectionElement +instance ElementClass HTMLTableSectionElement +instance NodeClass HTMLTableSectionElement +instance EventTargetClass HTMLTableSectionElement +instance GObjectClass HTMLTableSectionElement where + toGObject = GObject . castForeignPtr . unHTMLTableSectionElement + unsafeCastGObject = HTMLTableSectionElement . castForeignPtr . unGObject + +castToHTMLTableSectionElement :: GObjectClass obj => obj -> HTMLTableSectionElement +castToHTMLTableSectionElement = castTo gTypeHTMLTableSectionElement "HTMLTableSectionElement" + +gTypeHTMLTableSectionElement :: GType +gTypeHTMLTableSectionElement = + {# call fun unsafe webkit_dom_html_table_section_element_get_type #} + +-- ******************************************************** HTMLTextAreaElement + +{#pointer *WebKitDOMHTMLTextAreaElement as HTMLTextAreaElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLTextAreaElement = (HTMLTextAreaElement, objectUnrefFromMainloop) +unHTMLTextAreaElement (HTMLTextAreaElement o) = o + +class HTMLElementClass o => HTMLTextAreaElementClass o +toHTMLTextAreaElement :: HTMLTextAreaElementClass o => o -> HTMLTextAreaElement +toHTMLTextAreaElement = unsafeCastGObject . toGObject + +instance HTMLTextAreaElementClass HTMLTextAreaElement +instance HTMLElementClass HTMLTextAreaElement +instance ElementClass HTMLTextAreaElement +instance NodeClass HTMLTextAreaElement +instance EventTargetClass HTMLTextAreaElement +instance GObjectClass HTMLTextAreaElement where + toGObject = GObject . castForeignPtr . unHTMLTextAreaElement + unsafeCastGObject = HTMLTextAreaElement . castForeignPtr . unGObject + +castToHTMLTextAreaElement :: GObjectClass obj => obj -> HTMLTextAreaElement +castToHTMLTextAreaElement = castTo gTypeHTMLTextAreaElement "HTMLTextAreaElement" + +gTypeHTMLTextAreaElement :: GType +gTypeHTMLTextAreaElement = + {# call fun unsafe webkit_dom_html_text_area_element_get_type #} + +-- *********************************************************** HTMLTitleElement + +{#pointer *WebKitDOMHTMLTitleElement as HTMLTitleElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLTitleElement = (HTMLTitleElement, objectUnrefFromMainloop) +unHTMLTitleElement (HTMLTitleElement o) = o + +class HTMLElementClass o => HTMLTitleElementClass o +toHTMLTitleElement :: HTMLTitleElementClass o => o -> HTMLTitleElement +toHTMLTitleElement = unsafeCastGObject . toGObject + +instance HTMLTitleElementClass HTMLTitleElement +instance HTMLElementClass HTMLTitleElement +instance ElementClass HTMLTitleElement +instance NodeClass HTMLTitleElement +instance EventTargetClass HTMLTitleElement +instance GObjectClass HTMLTitleElement where + toGObject = GObject . castForeignPtr . unHTMLTitleElement + unsafeCastGObject = HTMLTitleElement . castForeignPtr . unGObject + +castToHTMLTitleElement :: GObjectClass obj => obj -> HTMLTitleElement +castToHTMLTitleElement = castTo gTypeHTMLTitleElement "HTMLTitleElement" + +gTypeHTMLTitleElement :: GType +gTypeHTMLTitleElement = + {# call fun unsafe webkit_dom_html_title_element_get_type #} + +-- *********************************************************** HTMLUListElement + +{#pointer *WebKitDOMHTMLUListElement as HTMLUListElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLUListElement = (HTMLUListElement, objectUnrefFromMainloop) +unHTMLUListElement (HTMLUListElement o) = o + +class HTMLElementClass o => HTMLUListElementClass o +toHTMLUListElement :: HTMLUListElementClass o => o -> HTMLUListElement +toHTMLUListElement = unsafeCastGObject . toGObject + +instance HTMLUListElementClass HTMLUListElement +instance HTMLElementClass HTMLUListElement +instance ElementClass HTMLUListElement +instance NodeClass HTMLUListElement +instance EventTargetClass HTMLUListElement +instance GObjectClass HTMLUListElement where + toGObject = GObject . castForeignPtr . unHTMLUListElement + unsafeCastGObject = HTMLUListElement . castForeignPtr . unGObject + +castToHTMLUListElement :: GObjectClass obj => obj -> HTMLUListElement +castToHTMLUListElement = castTo gTypeHTMLUListElement "HTMLUListElement" + +gTypeHTMLUListElement :: GType +gTypeHTMLUListElement = + {# call fun unsafe webkit_dom_htmlu_list_element_get_type #} + +-- ************************************************************ EntityReference + +{#pointer *WebKitDOMEntityReference as EntityReference foreign newtype #} deriving (Eq,Ord) + +mkEntityReference = (EntityReference, objectUnrefFromMainloop) +unEntityReference (EntityReference o) = o + +class NodeClass o => EntityReferenceClass o +toEntityReference :: EntityReferenceClass o => o -> EntityReference +toEntityReference = unsafeCastGObject . toGObject + +instance EntityReferenceClass EntityReference +instance NodeClass EntityReference +instance EventTargetClass EntityReference +instance GObjectClass EntityReference where + toGObject = GObject . castForeignPtr . unEntityReference + unsafeCastGObject = EntityReference . castForeignPtr . unGObject + +castToEntityReference :: GObjectClass obj => obj -> EntityReference +castToEntityReference = castTo gTypeEntityReference "EntityReference" + +gTypeEntityReference :: GType +gTypeEntityReference = + {# call fun unsafe webkit_dom_entity_reference_get_type #} + +-- **************************************************************** Performance + +{#pointer *WebKitDOMPerformance as Performance foreign newtype #} deriving (Eq,Ord) + +mkPerformance = (Performance, objectUnrefFromMainloop) +unPerformance (Performance o) = o + +class EventTargetClass o => PerformanceClass o +toPerformance :: PerformanceClass o => o -> Performance +toPerformance = unsafeCastGObject . toGObject + +instance PerformanceClass Performance +instance EventTargetClass Performance +instance GObjectClass Performance where + toGObject = GObject . castForeignPtr . unPerformance + unsafeCastGObject = Performance . castForeignPtr . unGObject + +castToPerformance :: GObjectClass obj => obj -> Performance +castToPerformance = castTo gTypePerformance "Performance" + +gTypePerformance :: GType +gTypePerformance = + {# call fun unsafe webkit_dom_performance_get_type #} + +-- ****************************************************************** TextTrack + +{#pointer *WebKitDOMTextTrack as TextTrack foreign newtype #} deriving (Eq,Ord) + +mkTextTrack = (TextTrack, objectUnrefFromMainloop) +unTextTrack (TextTrack o) = o + +class EventTargetClass o => TextTrackClass o +toTextTrack :: TextTrackClass o => o -> TextTrack +toTextTrack = unsafeCastGObject . toGObject + +instance TextTrackClass TextTrack +instance EventTargetClass TextTrack +instance GObjectClass TextTrack where + toGObject = GObject . castForeignPtr . unTextTrack + unsafeCastGObject = TextTrack . castForeignPtr . unGObject + +castToTextTrack :: GObjectClass obj => obj -> TextTrack +castToTextTrack = castTo gTypeTextTrack "TextTrack" + +gTypeTextTrack :: GType +gTypeTextTrack = + {# call fun unsafe webkit_dom_text_track_get_type #} + +-- *************************************************************** TextTrackCue + +{#pointer *WebKitDOMTextTrackCue as TextTrackCue foreign newtype #} deriving (Eq,Ord) + +mkTextTrackCue = (TextTrackCue, objectUnrefFromMainloop) +unTextTrackCue (TextTrackCue o) = o + +class EventTargetClass o => TextTrackCueClass o +toTextTrackCue :: TextTrackCueClass o => o -> TextTrackCue +toTextTrackCue = unsafeCastGObject . toGObject + +instance TextTrackCueClass TextTrackCue +instance EventTargetClass TextTrackCue +instance GObjectClass TextTrackCue where + toGObject = GObject . castForeignPtr . unTextTrackCue + unsafeCastGObject = TextTrackCue . castForeignPtr . unGObject + +castToTextTrackCue :: GObjectClass obj => obj -> TextTrackCue +castToTextTrackCue = castTo gTypeTextTrackCue "TextTrackCue" + +gTypeTextTrackCue :: GType +gTypeTextTrackCue = + {# call fun unsafe webkit_dom_text_track_cue_get_type #} + +-- ************************************************************** TextTrackList + +{#pointer *WebKitDOMTextTrackList as TextTrackList foreign newtype #} deriving (Eq,Ord) + +mkTextTrackList = (TextTrackList, objectUnrefFromMainloop) +unTextTrackList (TextTrackList o) = o + +class EventTargetClass o => TextTrackListClass o +toTextTrackList :: TextTrackListClass o => o -> TextTrackList +toTextTrackList = unsafeCastGObject . toGObject + +instance TextTrackListClass TextTrackList +instance EventTargetClass TextTrackList +instance GObjectClass TextTrackList where + toGObject = GObject . castForeignPtr . unTextTrackList + unsafeCastGObject = TextTrackList . castForeignPtr . unGObject + +castToTextTrackList :: GObjectClass obj => obj -> TextTrackList +castToTextTrackList = castTo gTypeTextTrackList "TextTrackList" + +gTypeTextTrackList :: GType +gTypeTextTrackList = + {# call fun unsafe webkit_dom_text_track_list_get_type #} + +-- ************************************************************* VideoTrackList + +{#pointer *WebKitDOMVideoTrackList as VideoTrackList foreign newtype #} deriving (Eq,Ord) + +mkVideoTrackList = (VideoTrackList, objectUnrefFromMainloop) +unVideoTrackList (VideoTrackList o) = o + +class EventTargetClass o => VideoTrackListClass o +toVideoTrackList :: VideoTrackListClass o => o -> VideoTrackList +toVideoTrackList = unsafeCastGObject . toGObject + +instance VideoTrackListClass VideoTrackList +instance EventTargetClass VideoTrackList +instance GObjectClass VideoTrackList where + toGObject = GObject . castForeignPtr . unVideoTrackList + unsafeCastGObject = VideoTrackList . castForeignPtr . unGObject + +castToVideoTrackList :: GObjectClass obj => obj -> VideoTrackList +castToVideoTrackList = castTo gTypeVideoTrackList "VideoTrackList" + +gTypeVideoTrackList :: GType +gTypeVideoTrackList = + {# call fun unsafe webkit_dom_video_track_list_get_type #} + +-- ************************************************************ WebKitNamedFlow + +{#pointer *WebKitDOMWebKitNamedFlow as WebKitNamedFlow foreign newtype #} deriving (Eq,Ord) + +mkWebKitNamedFlow = (WebKitNamedFlow, objectUnrefFromMainloop) +unWebKitNamedFlow (WebKitNamedFlow o) = o + +class EventTargetClass o => WebKitNamedFlowClass o +toWebKitNamedFlow :: WebKitNamedFlowClass o => o -> WebKitNamedFlow +toWebKitNamedFlow = unsafeCastGObject . toGObject + +instance WebKitNamedFlowClass WebKitNamedFlow +instance EventTargetClass WebKitNamedFlow +instance GObjectClass WebKitNamedFlow where + toGObject = GObject . castForeignPtr . unWebKitNamedFlow + unsafeCastGObject = WebKitNamedFlow . castForeignPtr . unGObject + +castToWebKitNamedFlow :: GObjectClass obj => obj -> WebKitNamedFlow +castToWebKitNamedFlow = castTo gTypeWebKitNamedFlow "WebKitNamedFlow" + +gTypeWebKitNamedFlow :: GType +gTypeWebKitNamedFlow = + {# call fun unsafe webkit_dom_webkit_named_flow_get_type #} + +-- ********************************************************************* Window + +{#pointer *WebKitDOMDOMWindow as Window foreign newtype #} deriving (Eq,Ord) + +mkWindow = (Window, objectUnrefFromMainloop) +unWindow (Window o) = o + +class EventTargetClass o => WindowClass o +toWindow :: WindowClass o => o -> Window +toWindow = unsafeCastGObject . toGObject + +instance WindowClass Window +instance EventTargetClass Window +instance GObjectClass Window where + toGObject = GObject . castForeignPtr . unWindow + unsafeCastGObject = Window . castForeignPtr . unGObject + +castToWindow :: GObjectClass obj => obj -> Window +castToWindow = castTo gTypeWindow "Window" + +gTypeWindow :: GType +gTypeWindow = + {# call fun unsafe webkit_dom_dom_window_get_type #} + +-- ******************************************************************* FileList + +{#pointer *WebKitDOMFileList as FileList foreign newtype #} deriving (Eq,Ord) + +mkFileList = (FileList, objectUnrefFromMainloop) +unFileList (FileList o) = o + +class GObjectClass o => FileListClass o +toFileList :: FileListClass o => o -> FileList +toFileList = unsafeCastGObject . toGObject + +instance FileListClass FileList +instance GObjectClass FileList where + toGObject = GObject . castForeignPtr . unFileList + unsafeCastGObject = FileList . castForeignPtr . unGObject + +castToFileList :: GObjectClass obj => obj -> FileList +castToFileList = castTo gTypeFileList "FileList" + +gTypeFileList :: GType +gTypeFileList = + {# call fun unsafe webkit_dom_file_list_get_type #} + +-- **************************************************************** Geolocation + +{#pointer *WebKitDOMGeolocation as Geolocation foreign newtype #} deriving (Eq,Ord) + +mkGeolocation = (Geolocation, objectUnrefFromMainloop) +unGeolocation (Geolocation o) = o + +class GObjectClass o => GeolocationClass o +toGeolocation :: GeolocationClass o => o -> Geolocation +toGeolocation = unsafeCastGObject . toGObject + +instance GeolocationClass Geolocation +instance GObjectClass Geolocation where + toGObject = GObject . castForeignPtr . unGeolocation + unsafeCastGObject = Geolocation . castForeignPtr . unGObject + +castToGeolocation :: GObjectClass obj => obj -> Geolocation +castToGeolocation = castTo gTypeGeolocation "Geolocation" + +gTypeGeolocation :: GType +gTypeGeolocation = + {# call fun unsafe webkit_dom_geolocation_get_type #} + +-- ************************************************************* HTMLCollection + +{#pointer *WebKitDOMHTMLCollection as HTMLCollection foreign newtype #} deriving (Eq,Ord) + +mkHTMLCollection = (HTMLCollection, objectUnrefFromMainloop) +unHTMLCollection (HTMLCollection o) = o + +class GObjectClass o => HTMLCollectionClass o +toHTMLCollection :: HTMLCollectionClass o => o -> HTMLCollection +toHTMLCollection = unsafeCastGObject . toGObject + +instance HTMLCollectionClass HTMLCollection +instance GObjectClass HTMLCollection where + toGObject = GObject . castForeignPtr . unHTMLCollection + unsafeCastGObject = HTMLCollection . castForeignPtr . unGObject + +castToHTMLCollection :: GObjectClass obj => obj -> HTMLCollection +castToHTMLCollection = castTo gTypeHTMLCollection "HTMLCollection" + +gTypeHTMLCollection :: GType +gTypeHTMLCollection = + {# call fun unsafe webkit_dom_html_collection_get_type #} + +-- ****************************************************** HTMLOptionsCollection + +{#pointer *WebKitDOMHTMLOptionsCollection as HTMLOptionsCollection foreign newtype #} deriving (Eq,Ord) + +mkHTMLOptionsCollection = (HTMLOptionsCollection, objectUnrefFromMainloop) +unHTMLOptionsCollection (HTMLOptionsCollection o) = o + +class HTMLCollectionClass o => HTMLOptionsCollectionClass o +toHTMLOptionsCollection :: HTMLOptionsCollectionClass o => o -> HTMLOptionsCollection +toHTMLOptionsCollection = unsafeCastGObject . toGObject + +instance HTMLOptionsCollectionClass HTMLOptionsCollection +instance HTMLCollectionClass HTMLOptionsCollection +instance GObjectClass HTMLOptionsCollection where + toGObject = GObject . castForeignPtr . unHTMLOptionsCollection + unsafeCastGObject = HTMLOptionsCollection . castForeignPtr . unGObject + +castToHTMLOptionsCollection :: GObjectClass obj => obj -> HTMLOptionsCollection +castToHTMLOptionsCollection = castTo gTypeHTMLOptionsCollection "HTMLOptionsCollection" + +gTypeHTMLOptionsCollection :: GType +gTypeHTMLOptionsCollection = + {# call fun unsafe webkit_dom_html_options_collection_get_type #} + +-- *********************************************************** HTMLMediaElement + +{#pointer *WebKitDOMHTMLMediaElement as HTMLMediaElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLMediaElement = (HTMLMediaElement, objectUnrefFromMainloop) +unHTMLMediaElement (HTMLMediaElement o) = o + +class GObjectClass o => HTMLMediaElementClass o +toHTMLMediaElement :: HTMLMediaElementClass o => o -> HTMLMediaElement +toHTMLMediaElement = unsafeCastGObject . toGObject + +instance HTMLMediaElementClass HTMLMediaElement +instance GObjectClass HTMLMediaElement where + toGObject = GObject . castForeignPtr . unHTMLMediaElement + unsafeCastGObject = HTMLMediaElement . castForeignPtr . unGObject + +castToHTMLMediaElement :: GObjectClass obj => obj -> HTMLMediaElement +castToHTMLMediaElement = castTo gTypeHTMLMediaElement "HTMLMediaElement" + +gTypeHTMLMediaElement :: GType +gTypeHTMLMediaElement = + {# call fun unsafe webkit_dom_html_media_element_get_type #} + +-- *********************************************************** HTMLAudioElement + +{#pointer *WebKitDOMHTMLAudioElement as HTMLAudioElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLAudioElement = (HTMLAudioElement, objectUnrefFromMainloop) +unHTMLAudioElement (HTMLAudioElement o) = o + +class HTMLMediaElementClass o => HTMLAudioElementClass o +toHTMLAudioElement :: HTMLAudioElementClass o => o -> HTMLAudioElement +toHTMLAudioElement = unsafeCastGObject . toGObject + +instance HTMLAudioElementClass HTMLAudioElement +instance HTMLMediaElementClass HTMLAudioElement +instance GObjectClass HTMLAudioElement where + toGObject = GObject . castForeignPtr . unHTMLAudioElement + unsafeCastGObject = HTMLAudioElement . castForeignPtr . unGObject + +castToHTMLAudioElement :: GObjectClass obj => obj -> HTMLAudioElement +castToHTMLAudioElement = castTo gTypeHTMLAudioElement "HTMLAudioElement" + +gTypeHTMLAudioElement :: GType +gTypeHTMLAudioElement = + {# call fun unsafe webkit_dom_html_audio_element_get_type #} + +-- *********************************************************** HTMLVideoElement + +{#pointer *WebKitDOMHTMLVideoElement as HTMLVideoElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLVideoElement = (HTMLVideoElement, objectUnrefFromMainloop) +unHTMLVideoElement (HTMLVideoElement o) = o + +class HTMLMediaElementClass o => HTMLVideoElementClass o +toHTMLVideoElement :: HTMLVideoElementClass o => o -> HTMLVideoElement +toHTMLVideoElement = unsafeCastGObject . toGObject + +instance HTMLVideoElementClass HTMLVideoElement +instance HTMLMediaElementClass HTMLVideoElement +instance GObjectClass HTMLVideoElement where + toGObject = GObject . castForeignPtr . unHTMLVideoElement + unsafeCastGObject = HTMLVideoElement . castForeignPtr . unGObject + +castToHTMLVideoElement :: GObjectClass obj => obj -> HTMLVideoElement +castToHTMLVideoElement = castTo gTypeHTMLVideoElement "HTMLVideoElement" + +gTypeHTMLVideoElement :: GType +gTypeHTMLVideoElement = + {# call fun unsafe webkit_dom_html_video_element_get_type #} + +-- ******************************************************************** History + +{#pointer *WebKitDOMHistory as History foreign newtype #} deriving (Eq,Ord) + +mkHistory = (History, objectUnrefFromMainloop) +unHistory (History o) = o + +class GObjectClass o => HistoryClass o +toHistory :: HistoryClass o => o -> History +toHistory = unsafeCastGObject . toGObject + +instance HistoryClass History +instance GObjectClass History where + toGObject = GObject . castForeignPtr . unHistory + unsafeCastGObject = History . castForeignPtr . unGObject + +castToHistory :: GObjectClass obj => obj -> History +castToHistory = castTo gTypeHistory "History" + +gTypeHistory :: GType +gTypeHistory = + {# call fun unsafe webkit_dom_history_get_type #} + +-- ******************************************************************* Location + +{#pointer *WebKitDOMLocation as Location foreign newtype #} deriving (Eq,Ord) + +mkLocation = (Location, objectUnrefFromMainloop) +unLocation (Location o) = o + +class GObjectClass o => LocationClass o +toLocation :: LocationClass o => o -> Location +toLocation = unsafeCastGObject . toGObject + +instance LocationClass Location +instance GObjectClass Location where + toGObject = GObject . castForeignPtr . unLocation + unsafeCastGObject = Location . castForeignPtr . unGObject + +castToLocation :: GObjectClass obj => obj -> Location +castToLocation = castTo gTypeLocation "Location" + +gTypeLocation :: GType +gTypeLocation = + {# call fun unsafe webkit_dom_location_get_type #} + +-- ***************************************************************** MediaError + +{#pointer *WebKitDOMMediaError as MediaError foreign newtype #} deriving (Eq,Ord) + +mkMediaError = (MediaError, objectUnrefFromMainloop) +unMediaError (MediaError o) = o + +class GObjectClass o => MediaErrorClass o +toMediaError :: MediaErrorClass o => o -> MediaError +toMediaError = unsafeCastGObject . toGObject + +instance MediaErrorClass MediaError +instance GObjectClass MediaError where + toGObject = GObject . castForeignPtr . unMediaError + unsafeCastGObject = MediaError . castForeignPtr . unGObject + +castToMediaError :: GObjectClass obj => obj -> MediaError +castToMediaError = castTo gTypeMediaError "MediaError" + +gTypeMediaError :: GType +gTypeMediaError = + {# call fun unsafe webkit_dom_media_error_get_type #} + +-- ****************************************************************** MediaList + +{#pointer *WebKitDOMMediaList as MediaList foreign newtype #} deriving (Eq,Ord) + +mkMediaList = (MediaList, objectUnrefFromMainloop) +unMediaList (MediaList o) = o + +class GObjectClass o => MediaListClass o +toMediaList :: MediaListClass o => o -> MediaList +toMediaList = unsafeCastGObject . toGObject + +instance MediaListClass MediaList +instance GObjectClass MediaList where + toGObject = GObject . castForeignPtr . unMediaList + unsafeCastGObject = MediaList . castForeignPtr . unGObject + +castToMediaList :: GObjectClass obj => obj -> MediaList +castToMediaList = castTo gTypeMediaList "MediaList" + +gTypeMediaList :: GType +gTypeMediaList = + {# call fun unsafe webkit_dom_media_list_get_type #} + +-- ************************************************************* MediaQueryList + +{#pointer *WebKitDOMMediaQueryList as MediaQueryList foreign newtype #} deriving (Eq,Ord) + +mkMediaQueryList = (MediaQueryList, objectUnrefFromMainloop) +unMediaQueryList (MediaQueryList o) = o + +class GObjectClass o => MediaQueryListClass o +toMediaQueryList :: MediaQueryListClass o => o -> MediaQueryList +toMediaQueryList = unsafeCastGObject . toGObject + +instance MediaQueryListClass MediaQueryList +instance GObjectClass MediaQueryList where + toGObject = GObject . castForeignPtr . unMediaQueryList + unsafeCastGObject = MediaQueryList . castForeignPtr . unGObject + +castToMediaQueryList :: GObjectClass obj => obj -> MediaQueryList +castToMediaQueryList = castTo gTypeMediaQueryList "MediaQueryList" + +gTypeMediaQueryList :: GType +gTypeMediaQueryList = + {# call fun unsafe webkit_dom_media_query_list_get_type #} + +-- ******************************************************************* MimeType + +{#pointer *WebKitDOMDOMMimeType as MimeType foreign newtype #} deriving (Eq,Ord) + +mkMimeType = (MimeType, objectUnrefFromMainloop) +unMimeType (MimeType o) = o + +class GObjectClass o => MimeTypeClass o +toMimeType :: MimeTypeClass o => o -> MimeType +toMimeType = unsafeCastGObject . toGObject + +instance MimeTypeClass MimeType +instance GObjectClass MimeType where + toGObject = GObject . castForeignPtr . unMimeType + unsafeCastGObject = MimeType . castForeignPtr . unGObject + +castToMimeType :: GObjectClass obj => obj -> MimeType +castToMimeType = castTo gTypeMimeType "MimeType" + +gTypeMimeType :: GType +gTypeMimeType = + {# call fun unsafe webkit_dom_dom_mime_type_get_type #} + +-- ************************************************************** MimeTypeArray + +{#pointer *WebKitDOMDOMMimeTypeArray as MimeTypeArray foreign newtype #} deriving (Eq,Ord) + +mkMimeTypeArray = (MimeTypeArray, objectUnrefFromMainloop) +unMimeTypeArray (MimeTypeArray o) = o + +class GObjectClass o => MimeTypeArrayClass o +toMimeTypeArray :: MimeTypeArrayClass o => o -> MimeTypeArray +toMimeTypeArray = unsafeCastGObject . toGObject + +instance MimeTypeArrayClass MimeTypeArray +instance GObjectClass MimeTypeArray where + toGObject = GObject . castForeignPtr . unMimeTypeArray + unsafeCastGObject = MimeTypeArray . castForeignPtr . unGObject + +castToMimeTypeArray :: GObjectClass obj => obj -> MimeTypeArray +castToMimeTypeArray = castTo gTypeMimeTypeArray "MimeTypeArray" + +gTypeMimeTypeArray :: GType +gTypeMimeTypeArray = + {# call fun unsafe webkit_dom_dom_mime_type_array_get_type #} + +-- *************************************************************** NamedNodeMap + +{#pointer *WebKitDOMNamedNodeMap as NamedNodeMap foreign newtype #} deriving (Eq,Ord) + +mkNamedNodeMap = (NamedNodeMap, objectUnrefFromMainloop) +unNamedNodeMap (NamedNodeMap o) = o + +class GObjectClass o => NamedNodeMapClass o +toNamedNodeMap :: NamedNodeMapClass o => o -> NamedNodeMap +toNamedNodeMap = unsafeCastGObject . toGObject + +instance NamedNodeMapClass NamedNodeMap +instance GObjectClass NamedNodeMap where + toGObject = GObject . castForeignPtr . unNamedNodeMap + unsafeCastGObject = NamedNodeMap . castForeignPtr . unGObject + +castToNamedNodeMap :: GObjectClass obj => obj -> NamedNodeMap +castToNamedNodeMap = castTo gTypeNamedNodeMap "NamedNodeMap" + +gTypeNamedNodeMap :: GType +gTypeNamedNodeMap = + {# call fun unsafe webkit_dom_named_node_map_get_type #} + +-- ****************************************************************** Navigator + +{#pointer *WebKitDOMNavigator as Navigator foreign newtype #} deriving (Eq,Ord) + +mkNavigator = (Navigator, objectUnrefFromMainloop) +unNavigator (Navigator o) = o + +class GObjectClass o => NavigatorClass o +toNavigator :: NavigatorClass o => o -> Navigator +toNavigator = unsafeCastGObject . toGObject + +instance NavigatorClass Navigator +instance GObjectClass Navigator where + toGObject = GObject . castForeignPtr . unNavigator + unsafeCastGObject = Navigator . castForeignPtr . unGObject + +castToNavigator :: GObjectClass obj => obj -> Navigator +castToNavigator = castTo gTypeNavigator "Navigator" + +gTypeNavigator :: GType +gTypeNavigator = + {# call fun unsafe webkit_dom_navigator_get_type #} + +-- ***************************************************************** NodeFilter + +{#pointer *WebKitDOMNodeFilter as NodeFilter foreign newtype #} deriving (Eq,Ord) + +mkNodeFilter = (NodeFilter, objectUnrefFromMainloop) +unNodeFilter (NodeFilter o) = o + +class GObjectClass o => NodeFilterClass o +toNodeFilter :: NodeFilterClass o => o -> NodeFilter +toNodeFilter = unsafeCastGObject . toGObject + +instance NodeFilterClass NodeFilter +instance GObjectClass NodeFilter where + toGObject = GObject . castForeignPtr . unNodeFilter + unsafeCastGObject = NodeFilter . castForeignPtr . unGObject + +castToNodeFilter :: GObjectClass obj => obj -> NodeFilter +castToNodeFilter = castTo gTypeNodeFilter "NodeFilter" + +gTypeNodeFilter :: GType +gTypeNodeFilter = + {# call fun unsafe webkit_dom_node_filter_get_type #} + +-- *************************************************************** NodeIterator + +{#pointer *WebKitDOMNodeIterator as NodeIterator foreign newtype #} deriving (Eq,Ord) + +mkNodeIterator = (NodeIterator, objectUnrefFromMainloop) +unNodeIterator (NodeIterator o) = o + +class GObjectClass o => NodeIteratorClass o +toNodeIterator :: NodeIteratorClass o => o -> NodeIterator +toNodeIterator = unsafeCastGObject . toGObject + +instance NodeIteratorClass NodeIterator +instance GObjectClass NodeIterator where + toGObject = GObject . castForeignPtr . unNodeIterator + unsafeCastGObject = NodeIterator . castForeignPtr . unGObject + +castToNodeIterator :: GObjectClass obj => obj -> NodeIterator +castToNodeIterator = castTo gTypeNodeIterator "NodeIterator" + +gTypeNodeIterator :: GType +gTypeNodeIterator = + {# call fun unsafe webkit_dom_node_iterator_get_type #} + +-- ******************************************************************* NodeList + +{#pointer *WebKitDOMNodeList as NodeList foreign newtype #} deriving (Eq,Ord) + +mkNodeList = (NodeList, objectUnrefFromMainloop) +unNodeList (NodeList o) = o + +class GObjectClass o => NodeListClass o +toNodeList :: NodeListClass o => o -> NodeList +toNodeList = unsafeCastGObject . toGObject + +instance NodeListClass NodeList +instance GObjectClass NodeList where + toGObject = GObject . castForeignPtr . unNodeList + unsafeCastGObject = NodeList . castForeignPtr . unGObject + +castToNodeList :: GObjectClass obj => obj -> NodeList +castToNodeList = castTo gTypeNodeList "NodeList" + +gTypeNodeList :: GType +gTypeNodeList = + {# call fun unsafe webkit_dom_node_list_get_type #} + +-- ****************************************************** PerformanceNavigation + +{#pointer *WebKitDOMPerformanceNavigation as PerformanceNavigation foreign newtype #} deriving (Eq,Ord) + +mkPerformanceNavigation = (PerformanceNavigation, objectUnrefFromMainloop) +unPerformanceNavigation (PerformanceNavigation o) = o + +class GObjectClass o => PerformanceNavigationClass o +toPerformanceNavigation :: PerformanceNavigationClass o => o -> PerformanceNavigation +toPerformanceNavigation = unsafeCastGObject . toGObject + +instance PerformanceNavigationClass PerformanceNavigation +instance GObjectClass PerformanceNavigation where + toGObject = GObject . castForeignPtr . unPerformanceNavigation + unsafeCastGObject = PerformanceNavigation . castForeignPtr . unGObject + +castToPerformanceNavigation :: GObjectClass obj => obj -> PerformanceNavigation +castToPerformanceNavigation = castTo gTypePerformanceNavigation "PerformanceNavigation" + +gTypePerformanceNavigation :: GType +gTypePerformanceNavigation = + {# call fun unsafe webkit_dom_performance_navigation_get_type #} + +-- ********************************************************** PerformanceTiming + +{#pointer *WebKitDOMPerformanceTiming as PerformanceTiming foreign newtype #} deriving (Eq,Ord) + +mkPerformanceTiming = (PerformanceTiming, objectUnrefFromMainloop) +unPerformanceTiming (PerformanceTiming o) = o + +class GObjectClass o => PerformanceTimingClass o +toPerformanceTiming :: PerformanceTimingClass o => o -> PerformanceTiming +toPerformanceTiming = unsafeCastGObject . toGObject + +instance PerformanceTimingClass PerformanceTiming +instance GObjectClass PerformanceTiming where + toGObject = GObject . castForeignPtr . unPerformanceTiming + unsafeCastGObject = PerformanceTiming . castForeignPtr . unGObject + +castToPerformanceTiming :: GObjectClass obj => obj -> PerformanceTiming +castToPerformanceTiming = castTo gTypePerformanceTiming "PerformanceTiming" + +gTypePerformanceTiming :: GType +gTypePerformanceTiming = + {# call fun unsafe webkit_dom_performance_timing_get_type #} + +-- ********************************************************************* Plugin + +{#pointer *WebKitDOMDOMPlugin as Plugin foreign newtype #} deriving (Eq,Ord) + +mkPlugin = (Plugin, objectUnrefFromMainloop) +unPlugin (Plugin o) = o + +class GObjectClass o => PluginClass o +toPlugin :: PluginClass o => o -> Plugin +toPlugin = unsafeCastGObject . toGObject + +instance PluginClass Plugin +instance GObjectClass Plugin where + toGObject = GObject . castForeignPtr . unPlugin + unsafeCastGObject = Plugin . castForeignPtr . unGObject + +castToPlugin :: GObjectClass obj => obj -> Plugin +castToPlugin = castTo gTypePlugin "Plugin" + +gTypePlugin :: GType +gTypePlugin = + {# call fun unsafe webkit_dom_dom_plugin_get_type #} + +-- **************************************************************** PluginArray + +{#pointer *WebKitDOMDOMPluginArray as PluginArray foreign newtype #} deriving (Eq,Ord) + +mkPluginArray = (PluginArray, objectUnrefFromMainloop) +unPluginArray (PluginArray o) = o + +class GObjectClass o => PluginArrayClass o +toPluginArray :: PluginArrayClass o => o -> PluginArray +toPluginArray = unsafeCastGObject . toGObject + +instance PluginArrayClass PluginArray +instance GObjectClass PluginArray where + toGObject = GObject . castForeignPtr . unPluginArray + unsafeCastGObject = PluginArray . castForeignPtr . unGObject + +castToPluginArray :: GObjectClass obj => obj -> PluginArray +castToPluginArray = castTo gTypePluginArray "PluginArray" + +gTypePluginArray :: GType +gTypePluginArray = + {# call fun unsafe webkit_dom_dom_plugin_array_get_type #} + +-- ********************************************************************** Range + +{#pointer *WebKitDOMRange as Range foreign newtype #} deriving (Eq,Ord) + +mkRange = (Range, objectUnrefFromMainloop) +unRange (Range o) = o + +class GObjectClass o => RangeClass o +toRange :: RangeClass o => o -> Range +toRange = unsafeCastGObject . toGObject + +instance RangeClass Range +instance GObjectClass Range where + toGObject = GObject . castForeignPtr . unRange + unsafeCastGObject = Range . castForeignPtr . unGObject + +castToRange :: GObjectClass obj => obj -> Range +castToRange = castTo gTypeRange "Range" + +gTypeRange :: GType +gTypeRange = + {# call fun unsafe webkit_dom_range_get_type #} + +-- ********************************************************************* Screen + +{#pointer *WebKitDOMScreen as Screen foreign newtype #} deriving (Eq,Ord) + +mkScreen = (Screen, objectUnrefFromMainloop) +unScreen (Screen o) = o + +class GObjectClass o => ScreenClass o +toScreen :: ScreenClass o => o -> Screen +toScreen = unsafeCastGObject . toGObject + +instance ScreenClass Screen +instance GObjectClass Screen where + toGObject = GObject . castForeignPtr . unScreen + unsafeCastGObject = Screen . castForeignPtr . unGObject + +castToScreen :: GObjectClass obj => obj -> Screen +castToScreen = castTo gTypeScreen "Screen" + +gTypeScreen :: GType +gTypeScreen = + {# call fun unsafe webkit_dom_screen_get_type #} + +-- ************************************************************* SecurityPolicy + +{#pointer *WebKitDOMDOMSecurityPolicy as SecurityPolicy foreign newtype #} deriving (Eq,Ord) + +mkSecurityPolicy = (SecurityPolicy, objectUnrefFromMainloop) +unSecurityPolicy (SecurityPolicy o) = o + +class GObjectClass o => SecurityPolicyClass o +toSecurityPolicy :: SecurityPolicyClass o => o -> SecurityPolicy +toSecurityPolicy = unsafeCastGObject . toGObject + +instance SecurityPolicyClass SecurityPolicy +instance GObjectClass SecurityPolicy where + toGObject = GObject . castForeignPtr . unSecurityPolicy + unsafeCastGObject = SecurityPolicy . castForeignPtr . unGObject + +castToSecurityPolicy :: GObjectClass obj => obj -> SecurityPolicy +castToSecurityPolicy = castTo gTypeSecurityPolicy "SecurityPolicy" + +gTypeSecurityPolicy :: GType +gTypeSecurityPolicy = + {# call fun unsafe webkit_dom_dom_security_policy_get_type #} + +-- ****************************************************************** Selection + +{#pointer *WebKitDOMDOMSelection as Selection foreign newtype #} deriving (Eq,Ord) + +mkSelection = (Selection, objectUnrefFromMainloop) +unSelection (Selection o) = o + +class GObjectClass o => SelectionClass o +toSelection :: SelectionClass o => o -> Selection +toSelection = unsafeCastGObject . toGObject + +instance SelectionClass Selection +instance GObjectClass Selection where + toGObject = GObject . castForeignPtr . unSelection + unsafeCastGObject = Selection . castForeignPtr . unGObject + +castToSelection :: GObjectClass obj => obj -> Selection +castToSelection = castTo gTypeSelection "Selection" + +gTypeSelection :: GType +gTypeSelection = + {# call fun unsafe webkit_dom_dom_selection_get_type #} + +-- ******************************************************************** Storage + +{#pointer *WebKitDOMStorage as Storage foreign newtype #} deriving (Eq,Ord) + +mkStorage = (Storage, objectUnrefFromMainloop) +unStorage (Storage o) = o + +class GObjectClass o => StorageClass o +toStorage :: StorageClass o => o -> Storage +toStorage = unsafeCastGObject . toGObject + +instance StorageClass Storage +instance GObjectClass Storage where + toGObject = GObject . castForeignPtr . unStorage + unsafeCastGObject = Storage . castForeignPtr . unGObject + +castToStorage :: GObjectClass obj => obj -> Storage +castToStorage = castTo gTypeStorage "Storage" + +gTypeStorage :: GType +gTypeStorage = + {# call fun unsafe webkit_dom_storage_get_type #} + +-- **************************************************************** StorageInfo + +{#pointer *WebKitDOMStorageInfo as StorageInfo foreign newtype #} deriving (Eq,Ord) + +mkStorageInfo = (StorageInfo, objectUnrefFromMainloop) +unStorageInfo (StorageInfo o) = o + +class GObjectClass o => StorageInfoClass o +toStorageInfo :: StorageInfoClass o => o -> StorageInfo +toStorageInfo = unsafeCastGObject . toGObject + +instance StorageInfoClass StorageInfo +instance GObjectClass StorageInfo where + toGObject = GObject . castForeignPtr . unStorageInfo + unsafeCastGObject = StorageInfo . castForeignPtr . unGObject + +castToStorageInfo :: GObjectClass obj => obj -> StorageInfo +castToStorageInfo = castTo gTypeStorageInfo "StorageInfo" + +gTypeStorageInfo :: GType +gTypeStorageInfo = + {# call fun unsafe webkit_dom_storage_info_get_type #} + +-- *************************************************************** StorageQuota + +{#pointer *WebKitDOMStorageQuota as StorageQuota foreign newtype #} deriving (Eq,Ord) + +mkStorageQuota = (StorageQuota, objectUnrefFromMainloop) +unStorageQuota (StorageQuota o) = o + +class GObjectClass o => StorageQuotaClass o +toStorageQuota :: StorageQuotaClass o => o -> StorageQuota +toStorageQuota = unsafeCastGObject . toGObject + +instance StorageQuotaClass StorageQuota +instance GObjectClass StorageQuota where + toGObject = GObject . castForeignPtr . unStorageQuota + unsafeCastGObject = StorageQuota . castForeignPtr . unGObject + +castToStorageQuota :: GObjectClass obj => obj -> StorageQuota +castToStorageQuota = castTo gTypeStorageQuota "StorageQuota" + +gTypeStorageQuota :: GType +gTypeStorageQuota = + {# call fun unsafe webkit_dom_storage_quota_get_type #} + +-- ***************************************************************** StyleMedia + +{#pointer *WebKitDOMStyleMedia as StyleMedia foreign newtype #} deriving (Eq,Ord) + +mkStyleMedia = (StyleMedia, objectUnrefFromMainloop) +unStyleMedia (StyleMedia o) = o + +class GObjectClass o => StyleMediaClass o +toStyleMedia :: StyleMediaClass o => o -> StyleMedia +toStyleMedia = unsafeCastGObject . toGObject + +instance StyleMediaClass StyleMedia +instance GObjectClass StyleMedia where + toGObject = GObject . castForeignPtr . unStyleMedia + unsafeCastGObject = StyleMedia . castForeignPtr . unGObject + +castToStyleMedia :: GObjectClass obj => obj -> StyleMedia +castToStyleMedia = castTo gTypeStyleMedia "StyleMedia" + +gTypeStyleMedia :: GType +gTypeStyleMedia = + {# call fun unsafe webkit_dom_style_media_get_type #} + +-- ***************************************************************** StyleSheet + +{#pointer *WebKitDOMStyleSheet as StyleSheet foreign newtype #} deriving (Eq,Ord) + +mkStyleSheet = (StyleSheet, objectUnrefFromMainloop) +unStyleSheet (StyleSheet o) = o + +class GObjectClass o => StyleSheetClass o +toStyleSheet :: StyleSheetClass o => o -> StyleSheet +toStyleSheet = unsafeCastGObject . toGObject + +instance StyleSheetClass StyleSheet +instance GObjectClass StyleSheet where + toGObject = GObject . castForeignPtr . unStyleSheet + unsafeCastGObject = StyleSheet . castForeignPtr . unGObject + +castToStyleSheet :: GObjectClass obj => obj -> StyleSheet +castToStyleSheet = castTo gTypeStyleSheet "StyleSheet" + +gTypeStyleSheet :: GType +gTypeStyleSheet = + {# call fun unsafe webkit_dom_style_sheet_get_type #} + +-- ************************************************************** CSSStyleSheet + +{#pointer *WebKitDOMCSSStyleSheet as CSSStyleSheet foreign newtype #} deriving (Eq,Ord) + +mkCSSStyleSheet = (CSSStyleSheet, objectUnrefFromMainloop) +unCSSStyleSheet (CSSStyleSheet o) = o + +class StyleSheetClass o => CSSStyleSheetClass o +toCSSStyleSheet :: CSSStyleSheetClass o => o -> CSSStyleSheet +toCSSStyleSheet = unsafeCastGObject . toGObject + +instance CSSStyleSheetClass CSSStyleSheet +instance StyleSheetClass CSSStyleSheet +instance GObjectClass CSSStyleSheet where + toGObject = GObject . castForeignPtr . unCSSStyleSheet + unsafeCastGObject = CSSStyleSheet . castForeignPtr . unGObject + +castToCSSStyleSheet :: GObjectClass obj => obj -> CSSStyleSheet +castToCSSStyleSheet = castTo gTypeCSSStyleSheet "CSSStyleSheet" + +gTypeCSSStyleSheet :: GType +gTypeCSSStyleSheet = + {# call fun unsafe webkit_dom_css_style_sheet_get_type #} + +-- ************************************************************* StyleSheetList + +{#pointer *WebKitDOMStyleSheetList as StyleSheetList foreign newtype #} deriving (Eq,Ord) + +mkStyleSheetList = (StyleSheetList, objectUnrefFromMainloop) +unStyleSheetList (StyleSheetList o) = o + +class GObjectClass o => StyleSheetListClass o +toStyleSheetList :: StyleSheetListClass o => o -> StyleSheetList +toStyleSheetList = unsafeCastGObject . toGObject + +instance StyleSheetListClass StyleSheetList +instance GObjectClass StyleSheetList where + toGObject = GObject . castForeignPtr . unStyleSheetList + unsafeCastGObject = StyleSheetList . castForeignPtr . unGObject + +castToStyleSheetList :: GObjectClass obj => obj -> StyleSheetList +castToStyleSheetList = castTo gTypeStyleSheetList "StyleSheetList" + +gTypeStyleSheetList :: GType +gTypeStyleSheetList = + {# call fun unsafe webkit_dom_style_sheet_list_get_type #} + +-- *********************************************************** TextTrackCueList + +{#pointer *WebKitDOMTextTrackCueList as TextTrackCueList foreign newtype #} deriving (Eq,Ord) + +mkTextTrackCueList = (TextTrackCueList, objectUnrefFromMainloop) +unTextTrackCueList (TextTrackCueList o) = o + +class GObjectClass o => TextTrackCueListClass o +toTextTrackCueList :: TextTrackCueListClass o => o -> TextTrackCueList +toTextTrackCueList = unsafeCastGObject . toGObject + +instance TextTrackCueListClass TextTrackCueList +instance GObjectClass TextTrackCueList where + toGObject = GObject . castForeignPtr . unTextTrackCueList + unsafeCastGObject = TextTrackCueList . castForeignPtr . unGObject + +castToTextTrackCueList :: GObjectClass obj => obj -> TextTrackCueList +castToTextTrackCueList = castTo gTypeTextTrackCueList "TextTrackCueList" + +gTypeTextTrackCueList :: GType +gTypeTextTrackCueList = + {# call fun unsafe webkit_dom_text_track_cue_list_get_type #} + +-- ***************************************************************** TimeRanges + +{#pointer *WebKitDOMTimeRanges as TimeRanges foreign newtype #} deriving (Eq,Ord) + +mkTimeRanges = (TimeRanges, objectUnrefFromMainloop) +unTimeRanges (TimeRanges o) = o + +class GObjectClass o => TimeRangesClass o +toTimeRanges :: TimeRangesClass o => o -> TimeRanges +toTimeRanges = unsafeCastGObject . toGObject + +instance TimeRangesClass TimeRanges +instance GObjectClass TimeRanges where + toGObject = GObject . castForeignPtr . unTimeRanges + unsafeCastGObject = TimeRanges . castForeignPtr . unGObject + +castToTimeRanges :: GObjectClass obj => obj -> TimeRanges +castToTimeRanges = castTo gTypeTimeRanges "TimeRanges" + +gTypeTimeRanges :: GType +gTypeTimeRanges = + {# call fun unsafe webkit_dom_time_ranges_get_type #} + +-- ********************************************************************** Touch + +{#pointer *WebKitDOMTouch as Touch foreign newtype #} deriving (Eq,Ord) + +mkTouch = (Touch, objectUnrefFromMainloop) +unTouch (Touch o) = o + +class GObjectClass o => TouchClass o +toTouch :: TouchClass o => o -> Touch +toTouch = unsafeCastGObject . toGObject + +instance TouchClass Touch +instance GObjectClass Touch where + toGObject = GObject . castForeignPtr . unTouch + unsafeCastGObject = Touch . castForeignPtr . unGObject + +castToTouch :: GObjectClass obj => obj -> Touch +castToTouch = castTo gTypeTouch "Touch" + +gTypeTouch :: GType +gTypeTouch = + {# call fun unsafe webkit_dom_touch_get_type #} + +-- ***************************************************************** TreeWalker + +{#pointer *WebKitDOMTreeWalker as TreeWalker foreign newtype #} deriving (Eq,Ord) + +mkTreeWalker = (TreeWalker, objectUnrefFromMainloop) +unTreeWalker (TreeWalker o) = o + +class GObjectClass o => TreeWalkerClass o +toTreeWalker :: TreeWalkerClass o => o -> TreeWalker +toTreeWalker = unsafeCastGObject . toGObject + +instance TreeWalkerClass TreeWalker +instance GObjectClass TreeWalker where + toGObject = GObject . castForeignPtr . unTreeWalker + unsafeCastGObject = TreeWalker . castForeignPtr . unGObject + +castToTreeWalker :: GObjectClass obj => obj -> TreeWalker +castToTreeWalker = castTo gTypeTreeWalker "TreeWalker" + +gTypeTreeWalker :: GType +gTypeTreeWalker = + {# call fun unsafe webkit_dom_tree_walker_get_type #} + +-- ************************************************************** ValidityState + +{#pointer *WebKitDOMValidityState as ValidityState foreign newtype #} deriving (Eq,Ord) + +mkValidityState = (ValidityState, objectUnrefFromMainloop) +unValidityState (ValidityState o) = o + +class GObjectClass o => ValidityStateClass o +toValidityState :: ValidityStateClass o => o -> ValidityState +toValidityState = unsafeCastGObject . toGObject + +instance ValidityStateClass ValidityState +instance GObjectClass ValidityState where + toGObject = GObject . castForeignPtr . unValidityState + unsafeCastGObject = ValidityState . castForeignPtr . unGObject + +castToValidityState :: GObjectClass obj => obj -> ValidityState +castToValidityState = castTo gTypeValidityState "ValidityState" + +gTypeValidityState :: GType +gTypeValidityState = + {# call fun unsafe webkit_dom_validity_state_get_type #} + +-- ***************************************************************** VideoTrack + +{#pointer *WebKitDOMVideoTrack as VideoTrack foreign newtype #} deriving (Eq,Ord) + +mkVideoTrack = (VideoTrack, objectUnrefFromMainloop) +unVideoTrack (VideoTrack o) = o + +class GObjectClass o => VideoTrackClass o +toVideoTrack :: VideoTrackClass o => o -> VideoTrack +toVideoTrack = unsafeCastGObject . toGObject + +instance VideoTrackClass VideoTrack +instance GObjectClass VideoTrack where + toGObject = GObject . castForeignPtr . unVideoTrack + unsafeCastGObject = VideoTrack . castForeignPtr . unGObject + +castToVideoTrack :: GObjectClass obj => obj -> VideoTrack +castToVideoTrack = castTo gTypeVideoTrack "VideoTrack" + +gTypeVideoTrack :: GType +gTypeVideoTrack = + {# call fun unsafe webkit_dom_video_track_get_type #} -- **************************************************************** WebKitPoint diff --git a/Graphics/UI/Gtk/WebKit/WebDataSource.chs b/Graphics/UI/Gtk/WebKit/WebDataSource.chs --- a/Graphics/UI/Gtk/WebKit/WebDataSource.chs +++ b/Graphics/UI/Gtk/WebKit/WebDataSource.chs @@ -22,7 +22,7 @@ -- -- Note -- --- Function `webkit_web_data_source_get_data` haven't binding, +-- Function `webkit_web_data_source_get_data` haven't binding, -- no idea how to handle `GString` -- -- Access to the WebKit Web DataSource @@ -48,7 +48,7 @@ -- * Constructors webDataSourceNew, --- * Methods +-- * Methods webDataSourceGetData, webDataSourceGetEncoding, webDataSourceGetInitialRequest, @@ -60,13 +60,14 @@ webDataSourceIsLoading, ) where -import Control.Monad (liftM) +import Control.Monad (liftM) +import Data.ByteString (ByteString) import System.Glib.FFI import System.Glib.UTFString import System.Glib.GList import System.Glib.GString -import System.Glib.GError +import System.Glib.GError import Graphics.UI.Gtk.Gdk.Events {#import Graphics.UI.Gtk.Abstract.Object#} (makeNewObject) @@ -75,32 +76,32 @@ {#context lib="webkit" prefix ="webkit"#} --- | Creates a new 'WebDataSource' instance. +-- | Creates a new 'WebDataSource' instance. -- The URL of the 'WebDataSource' will be set to "about:blank". webDataSourceNew :: IO WebDataSource -webDataSourceNew = - wrapNewGObject mkWebDataSource $ {#call web_data_source_new#} +webDataSourceNew = + wrapNewGObject mkWebDataSource $ {#call web_data_source_new#} -- | Returns the raw data that represents the the frame's content. The data will be incomplete until the -- data has finished loading. Returns 'Nothing' if the web frame hasn't loaded any data. Use -- @webkitWebDataSourceIsLoading@ to test if data source is in the process of loading. webDataSourceGetData :: WebDataSourceClass self => self - -> IO (Maybe String) + -> IO (Maybe ByteString) webDataSourceGetData ds = do gstr <- {#call webkit_web_data_source_get_data #} (toWebDataSource ds) - readGString gstr + readGStringByteString gstr -- | Returns the text encoding name as set in the 'WebView', or if not, the text encoding of the response. webDataSourceGetEncoding :: - WebDataSourceClass self => self - -> IO String -webDataSourceGetEncoding ds = - {#call web_data_source_get_encoding#} (toWebDataSource ds) >>= peekCString - --- | Returns a reference to the original request that was used to load the web content. + (WebDataSourceClass self, GlibString string) => self + -> IO string +webDataSourceGetEncoding ds = + {#call web_data_source_get_encoding#} (toWebDataSource ds) >>= peekUTFString + +-- | Returns a reference to the original request that was used to load the web content. -- The NetworkRequest returned by this method is the --- request prior to the "committed" load state. +-- request prior to the "committed" load state. -- See 'webDataSourceGetRequest' for getting the "committed" request. webDataSourceGetInitialRequest :: WebDataSourceClass self => self @@ -111,12 +112,12 @@ -- | Returns the main resource of the data_source webDataSourceGetMainResource :: WebDataSourceClass self => self - -> IO WebResource + -> IO WebResource webDataSourceGetMainResource ds = makeNewGObject mkWebResource $ {#call web_data_source_get_main_resource#} (toWebDataSource ds) - --- | Returns a NetworkRequest that was used to create this 'WebDataSource'. --- The NetworkRequest returned by this method is the request that was "committed", + +-- | Returns a NetworkRequest that was used to create this 'WebDataSource'. +-- The NetworkRequest returned by this method is the request that was "committed", -- and hence, different from the request you get from the 'webDataSourceGetInitialRequest' method. webDataSourceGetRequest :: WebDataSourceClass self => self @@ -127,21 +128,21 @@ -- | Gives you a List of 'WebResource' objects that compose the 'WebView' to which this 'WebDataSource' is attached. webDataSourceGetSubresources :: WebDataSourceClass self => self - -> IO [WebResource] + -> IO [WebResource] webDataSourceGetSubresources ds = do glist <- {#call web_data_source_get_subresources#} (toWebDataSource ds) resourcePtr <- fromGList glist mapM (makeNewGObject mkWebResource . return) resourcePtr --- | Return the unreachable URI of data_source. --- The 'dataSource' will have an unreachable URL --- if it was created using 'WebFrame''s +-- | Return the unreachable URI of data_source. +-- The 'dataSource' will have an unreachable URL +-- if it was created using 'WebFrame''s -- 'webFrameLoadAlternateHtmlString' method. webDataSourceGetUnreachableUri :: - WebDataSourceClass self => self - -> IO String + (WebDataSourceClass self, GlibString string) => self + -> IO string webDataSourceGetUnreachableUri ds = - {#call web_data_source_get_unreachable_uri#} (toWebDataSource ds) >>= peekCString + {#call web_data_source_get_unreachable_uri#} (toWebDataSource ds) >>= peekUTFString -- | Returns the 'WebFrame' that represents this data source webDataSourceGetWebFrame :: diff --git a/Graphics/UI/Gtk/WebKit/WebDatabase.chs b/Graphics/UI/Gtk/WebKit/WebDatabase.chs --- a/Graphics/UI/Gtk/WebKit/WebDatabase.chs +++ b/Graphics/UI/Gtk/WebKit/WebDatabase.chs @@ -28,19 +28,19 @@ -- | WebKitWebDatabase is a representation of a Web Database database. The proposed Web Database standard -- introduces support for SQL databases that web sites can create and access on a local computer -- through JavaScript. --- +-- -- To get access to all databases defined by a security origin, use -- 'securityOriginGetDatabases' Each database has a canonical name, as well as a user-friendly -- display name. --- +-- -- WebKit uses SQLite to create and access the local SQL databases. The location of a WebKitWebDatabase -- can be accessed wth 'webDatabaseGetFilename' You can configure the location of all -- databases with 'setDatabaseDirectoryPath'. --- +-- -- For each database the web site can define an estimated size which can be accessed with -- 'webDatabaseGetExpectedSize' The current size of the database in bytes is returned by -- 'webDatabaseGetSize'. --- +-- -- For more information refer to the Web Database specification proposal at -- http://dev.w3.org/html5/webdatabase @@ -48,7 +48,7 @@ WebDatabase, WebDatabaseClass, --- * Methods +-- * Methods webDatabaseGetDisplayName, webDatabaseGetExpectedSize, webDatabaseGetFilename, @@ -63,7 +63,7 @@ import System.Glib.FFI import System.Glib.UTFString import System.Glib.GList -import System.Glib.GError +import System.Glib.GError import Graphics.UI.Gtk.Gdk.Events {#import Graphics.UI.Gtk.Abstract.Object#} (makeNewObject) @@ -74,47 +74,47 @@ -- | Returns the name of the 'WebDatabase' as seen by the user. webDatabaseGetDisplayName :: - WebDatabaseClass self => self - -> IO String + (WebDatabaseClass self, GlibString string) => self + -> IO string webDatabaseGetDisplayName wd = - {#call web_database_get_display_name#} (toWebDatabase wd) >>= peekCString - + {#call web_database_get_display_name#} (toWebDatabase wd) >>= peekUTFString + -- | Returns the expected size of the Database in bytes as defined by the web author. The Web Database standard allows web authors to -- specify an expected size of the database to optimize the user experience. -webDatabaseGetExpectedSize :: +webDatabaseGetExpectedSize :: WebDatabaseClass self => self - -> IO Int + -> IO Int webDatabaseGetExpectedSize wd = liftM fromIntegral $ {#call web_database_get_expected_size#} (toWebDatabase wd) -- | Returns the absolute filename to the WebKitWebDatabase file on disk. webDatabaseGetFilename :: - WebDatabaseClass self => self - -> IO String -webDatabaseGetFilename wd = - {#call web_database_get_filename#} (toWebDatabase wd) >>= peekCString + (WebDatabaseClass self, GlibString string) => self + -> IO string +webDatabaseGetFilename wd = + {#call web_database_get_filename#} (toWebDatabase wd) >>= peekUTFString -- | Returns the canonical name of the 'WebDatabase'. webDatabaseGetName :: - WebDatabaseClass self => self - -> IO String -webDatabaseGetName wd = - {#call web_database_get_name#} (toWebDatabase wd) >>= peekCString + (WebDatabaseClass self, GlibString string) => self + -> IO string +webDatabaseGetName wd = + {#call web_database_get_name#} (toWebDatabase wd) >>= peekUTFString -- | Returns the security origin of the WebKitWebDatabase. -webDatabaseGetSecurityOrigin :: +webDatabaseGetSecurityOrigin :: WebDatabaseClass self => self - -> IO SecurityOrigin + -> IO SecurityOrigin webDatabaseGetSecurityOrigin wd = makeNewGObject mkSecurityOrigin $ {#call web_database_get_security_origin#} (toWebDatabase wd) --- | Returns the actual size of the 'WebDatabase' space on disk in bytes. +-- | Returns the actual size of the 'WebDatabase' space on disk in bytes. webDatabaseGetSize :: - WebDatabaseClass self => self + WebDatabaseClass self => self -> IO Int -webDatabaseGetSize wd = +webDatabaseGetSize wd = liftM fromIntegral $ {#call web_database_get_size#} (toWebDatabase wd) - + -- | Removes the 'WebDatabase' from its security origin and destroys all data stored in the database. webDatabaseRemove :: WebDatabaseClass self => self diff --git a/Graphics/UI/Gtk/WebKit/WebFrame.chs b/Graphics/UI/Gtk/WebKit/WebFrame.chs --- a/Graphics/UI/Gtk/WebKit/WebFrame.chs +++ b/Graphics/UI/Gtk/WebKit/WebFrame.chs @@ -5,7 +5,7 @@ -- Author : Cjacker Huang -- Copyright : (c) 2009 Cjacker Huang -- Copyright : (c) 2010 Andy Stewart --- +-- -- This library is free software; you can redistribute it and/or -- modify it under the terms of the GNU Lesser General Public -- License as published by the Free Software Foundation; either @@ -24,7 +24,7 @@ -- The content of a 'WebView' -- -- Note: --- Functon `webkit_web_frame_get_global_context` can't binding now, +-- Functon `webkit_web_frame_get_global_context` can't binding now, -- Because it need `JSGlobalContextRef` exist in JavaScriptCore. -- -- Function `webkit_web_frame_print_full` can't binding now, @@ -72,12 +72,13 @@ webFramePrint, ) where -import Control.Monad (liftM) +import Control.Monad (liftM) +import Data.ByteString (ByteString, useAsCString) import System.Glib.FFI import System.Glib.UTFString import System.Glib.GList -import System.Glib.GError +import System.Glib.GError import Graphics.UI.Gtk.Gdk.Events import Graphics.UI.Gtk.General.Enums @@ -98,209 +99,233 @@ -- | Create a new 'WebFrame' instance with the given @webview@. -- -- A 'WebFrame' contains the content of one URI. -webFrameNew :: +webFrameNew :: WebViewClass webview => webview -- ^ @webview@ - the given webview -> IO WebFrame -webFrameNew webview = +webFrameNew webview = wrapNewGObject mkWebFrame $ {#call web_frame_new#} (toWebView webview) -- | Return the 'WebView' that manages the given 'WebFrame'. -webFrameGetWebView :: +webFrameGetWebView :: WebFrameClass self => self -> IO WebView -webFrameGetWebView webframe = +webFrameGetWebView webframe = makeNewObject mkWebView $ liftM castPtr $ {#call web_frame_get_web_view#} (toWebFrame webframe) -- | Return the name of the given 'WebFrame'. -webFrameGetName :: - WebFrameClass self => self - -> IO (Maybe String) -- ^ the name string or @Nothing@ in case failed. -webFrameGetName webframe = - {#call web_frame_get_name#} (toWebFrame webframe) >>= maybePeek peekCString +webFrameGetName :: + (WebFrameClass self, GlibString string) => self + -> IO (Maybe string) -- ^ the name string or @Nothing@ in case failed. +webFrameGetName webframe = + {#call web_frame_get_name#} (toWebFrame webframe) >>= maybePeek peekUTFString #if WEBKIT_CHECK_VERSION (1,1,18) -- | Returns a WebKitNetworkResponse object representing the response that was given to the request for --- the given frame, or 'Nothing' if the frame was not created by a load. +-- the given frame, or 'Nothing' if the frame was not created by a load. -- -- * Since 1.1.18 webFrameGetNetworkResponse :: WebFrameClass self => self -> IO (Maybe NetworkResponse) webFrameGetNetworkResponse frame = - maybeNull (makeNewGObject mkNetworkResponse) $ + maybeNull (makeNewGObject mkNetworkResponse) $ {#call webkit_web_frame_get_network_response#} (toWebFrame frame) #endif -- | Return the title of the given 'WebFrame'. -webFrameGetTitle :: - WebFrameClass self => self - -> IO (Maybe String) -- ^ the title string or @Nothing@ in case failed. -webFrameGetTitle webframe = - {#call web_frame_get_title#} (toWebFrame webframe) >>= maybePeek peekCString +webFrameGetTitle :: + (WebFrameClass self, GlibString string) => self + -> IO (Maybe string) -- ^ the title string or @Nothing@ in case failed. +webFrameGetTitle webframe = + {#call web_frame_get_title#} (toWebFrame webframe) >>= maybePeek peekUTFString -- | Return the URI of the given 'WebFrame'. -webFrameGetUri :: - WebFrameClass self => self - -> IO (Maybe String) -- ^ the URI string or @Nothing@ in case failed. -webFrameGetUri webframe = - {#call web_frame_get_uri#} (toWebFrame webframe) >>= maybePeek peekCString +webFrameGetUri :: + (WebFrameClass self, GlibString string) => self + -> IO (Maybe string) -- ^ the URI string or @Nothing@ in case failed. +webFrameGetUri webframe = + {#call web_frame_get_uri#} (toWebFrame webframe) >>= maybePeek peekUTFString -- | Return the 'WebFrame''s parent frame if it has one, -- Otherwise return Nothing. -webFrameGetParent :: - WebFrameClass self => self +webFrameGetParent :: + WebFrameClass self => self -> IO (Maybe WebFrame) -- ^ a 'WebFrame' or @Nothing@ in case failed. -webFrameGetParent webframe = +webFrameGetParent webframe = maybeNull (makeNewGObject mkWebFrame) $ {#call web_frame_get_parent#} (toWebFrame webframe) -- | Determines the current status of the load. -- -- frame : a WebKitWebView --- +-- -- * Since 1.1.7 webFrameGetLoadStatus :: WebFrameClass self => self - -> IO LoadStatus + -> IO LoadStatus webFrameGetLoadStatus ls = liftM (toEnum . fromIntegral) $ {#call web_frame_get_load_status#} (toWebFrame ls) -- | Request loading of the specified URI string. -webFrameLoadUri :: - WebFrameClass self => self - -> String -- ^ @uri@ - an URI string. +webFrameLoadUri :: + (WebFrameClass self, GlibString string) => self + -> string -- ^ @uri@ - an URI string. -> IO () -webFrameLoadUri webframe uri = - withCString uri $ \uriPtr -> {#call web_frame_load_uri#} +webFrameLoadUri webframe uri = + withUTFString uri $ \uriPtr -> {#call web_frame_load_uri#} (toWebFrame webframe) uriPtr --- | Requests loading of the given @content@ +-- | Requests loading of the given @content@ +-- with the specified @mime_type@ and @base_uri@. +-- +-- If @mime_type@ is @Nothing@, \"text/html\" is assumed. +-- +-- If want control over the encoding use `webFrameLoadByteString` +webFrameLoadString :: + (WebFrameClass self, GlibString string) => self + -> string -- ^ @content@ - the content string to be loaded. + -> (Maybe string) -- ^ @mime_type@ - the MIME type or @Nothing@. + -> string -- ^ @base_uri@ - the base URI for relative locations. + -> IO() +webFrameLoadString webframe content mimetype baseuri = + withUTFString content $ \contentPtr -> + maybeWith withUTFString mimetype $ \mimetypePtr -> + withUTFString baseuri $ \baseuriPtr -> + {#call web_frame_load_string#} + (toWebFrame webframe) + contentPtr + mimetypePtr + nullPtr + baseuriPtr + +-- | Requests loading of the given @content@ -- with the specified @mime_type@, @encoding@ and @base_uri@. --- +-- -- If @mime_type@ is @Nothing@, \"text/html\" is assumed. -- -- If @encoding@ is @Nothing@, \"UTF-8\" is assumed. -webFrameLoadString :: - WebFrameClass self => self - -> String -- ^ @content@ - the content string to be loaded. - -> (Maybe String) -- ^ @mime_type@ - the MIME type or @Nothing@. - -> (Maybe String) -- ^ @encoding@ - the encoding or @Nothing@. - -> String -- ^ @base_uri@ - the base URI for relative locations. +webFrameLoadByteString :: + (WebFrameClass self, GlibString string) => self + -> ByteString -- ^ @content@ - the content string to be loaded. + -> (Maybe string) -- ^ @mime_type@ - the MIME type or @Nothing@. + -> (Maybe string) -- ^ @encoding@ - the encoding or @Nothing@. + -> string -- ^ @base_uri@ - the base URI for relative locations. -> IO() -webFrameLoadString webframe content mimetype encoding baseuri = - withCString content $ \contentPtr -> - maybeWith withCString mimetype $ \mimetypePtr -> - maybeWith withCString encoding $ \encodingPtr -> - withCString baseuri $ \baseuriPtr -> - {#call web_frame_load_string#} - (toWebFrame webframe) - contentPtr - mimetypePtr - encodingPtr +webFrameLoadByteString webframe content mimetype encoding baseuri = + useAsCString content $ \contentPtr -> + maybeWith withUTFString mimetype $ \mimetypePtr -> + maybeWith withUTFString encoding $ \encodingPtr -> + withUTFString baseuri $ \baseuriPtr -> + {#call web_frame_load_string#} + (toWebFrame webframe) + contentPtr + mimetypePtr + encodingPtr baseuriPtr + -- |Request loading of an alternate content for a URL that is unreachable. -- -- Using this method will preserve the back-forward list. --- The URI passed in @base_uri@ has to be an absolute URI. -webFrameLoadAlternateString :: - WebFrameClass self => self - -> String -- ^ @content@ - the alternate content to display +-- The URI passed in @base_uri@ has to be an absolute URI. +webFrameLoadAlternateString :: + (WebFrameClass self, GlibString string) => self + -> string -- ^ @content@ - the alternate content to display -- as the main page of the frame - -> String -- ^ @base_uri@ - the base URI for relative locations. - -> String -- ^ @unreachable_url@ - the URL for the alternate page content. + -> string -- ^ @base_uri@ - the base URI for relative locations. + -> string -- ^ @unreachable_url@ - the URL for the alternate page content. -> IO() -webFrameLoadAlternateString webframe content baseurl unreachableurl = - withCString content $ \contentPtr -> - withCString baseurl $ \baseurlPtr -> - withCString unreachableurl $ \unreachableurlPtr -> +webFrameLoadAlternateString webframe content baseurl unreachableurl = + withUTFString content $ \contentPtr -> + withUTFString baseurl $ \baseurlPtr -> + withUTFString unreachableurl $ \unreachableurlPtr -> {#call web_frame_load_alternate_string#} - (toWebFrame webframe) + (toWebFrame webframe) contentPtr baseurlPtr unreachableurlPtr -- | Connects to a given URI by initiating an asynchronous client request. -- --- Creates a provisional data source that will transition to a committed data source once any data has been received. --- Use 'webFrameStopLoading' to stop the load. +-- Creates a provisional data source that will transition to a committed data source once any data has been received. +-- Use 'webFrameStopLoading' to stop the load. -- This function is typically invoked on the main frame. -webFrameLoadRequest :: +webFrameLoadRequest :: (WebFrameClass self, NetworkRequestClass requ) => self -> requ -> IO () webFrameLoadRequest webframe request = - {#call web_frame_load_request#} (toWebFrame webframe) (toNetworkRequest request) + {#call web_frame_load_request#} (toWebFrame webframe) (toNetworkRequest request) -- | Stops and pending loads on the given data source and those of its children. -webFrameStopLoading :: +webFrameStopLoading :: WebFrameClass self => self -> IO() -webFrameStopLoading webframe = +webFrameStopLoading webframe = {#call web_frame_stop_loading#} (toWebFrame webframe) -- |Reloads the initial request. -webFrameReload :: +webFrameReload :: WebFrameClass self => self -> IO() -webFrameReload webframe = +webFrameReload webframe = {#call web_frame_reload#} (toWebFrame webframe) --- |Return the 'WebFrame' associated with the given name +-- |Return the 'WebFrame' associated with the given name -- or @Nothing@ in case none if found --- --- For pre-defined names, return the given webframe if name is -webFrameFindFrame:: - WebFrameClass self => self - -> String -- ^ @name@ - the name of the frame to be found. +-- +-- For pre-defined names, return the given webframe if name is +webFrameFindFrame:: + (WebFrameClass self, GlibString string) => self + -> string -- ^ @name@ - the name of the frame to be found. -> IO (Maybe WebFrame) -webFrameFindFrame webframe name = - withCString name $ \namePtr -> - maybeNull (makeNewGObject mkWebFrame) $ +webFrameFindFrame webframe name = + withUTFString name $ \namePtr -> + maybeNull (makeNewGObject mkWebFrame) $ {#call web_frame_find_frame#} (toWebFrame webframe) namePtr -- | Returns the committed data source. -webFrameGetDataSource :: +webFrameGetDataSource :: WebFrameClass self => self -> IO WebDataSource webFrameGetDataSource webframe = makeNewGObject mkWebDataSource $ {#call web_frame_get_data_source#} (toWebFrame webframe) -- | Return the policy of horizontal scrollbar. -webFrameGetHorizontalScrollbarPolicy :: +webFrameGetHorizontalScrollbarPolicy :: WebFrameClass self => self - -> IO PolicyType -webFrameGetHorizontalScrollbarPolicy webframe = + -> IO PolicyType +webFrameGetHorizontalScrollbarPolicy webframe = liftM (toEnum.fromIntegral) $ {#call web_frame_get_horizontal_scrollbar_policy#} (toWebFrame webframe) - + -- | Return the policy of vertical scrollbar. -webFrameGetVerticalScrollbarPolicy :: +webFrameGetVerticalScrollbarPolicy :: WebFrameClass self => self - -> IO PolicyType -webFrameGetVerticalScrollbarPolicy webframe = + -> IO PolicyType +webFrameGetVerticalScrollbarPolicy webframe = liftM (toEnum.fromIntegral) $ {#call web_frame_get_vertical_scrollbar_policy#} (toWebFrame webframe) --- | You use the 'webFrameLoadRequest' method to initiate a request that creates a provisional data source. --- The provisional data source will transition to a committed data source once any data has been received. +-- | You use the 'webFrameLoadRequest' method to initiate a request that creates a provisional data source. +-- The provisional data source will transition to a committed data source once any data has been received. -- Use 'webFrameGetDataSource' to get the committed data source. -webFrameGetProvisionalDataSource :: +webFrameGetProvisionalDataSource :: WebFrameClass self => self - -> IO WebDataSource + -> IO WebDataSource webFrameGetProvisionalDataSource webframe = makeNewGObject mkWebDataSource $ {#call web_frame_get_provisional_data_source#} (toWebFrame webframe) -- | Returns the frame's security origin. webFrameGetSecurityOrigin :: WebFrameClass self => self - -> IO SecurityOrigin -webFrameGetSecurityOrigin webframe = + -> IO SecurityOrigin +webFrameGetSecurityOrigin webframe = makeNewGObject mkSecurityOrigin $ {#call web_frame_get_security_origin#} (toWebFrame webframe) -- |Prints the given 'WebFrame'. -- --- by presenting a print dialog to the user. -webFramePrint:: +-- by presenting a print dialog to the user. +webFramePrint:: WebFrameClass self => self -> IO() -webFramePrint webframe = +webFramePrint webframe = {#call web_frame_print#} (toWebFrame webframe) diff --git a/Graphics/UI/Gtk/WebKit/WebHistoryItem.chs b/Graphics/UI/Gtk/WebKit/WebHistoryItem.chs --- a/Graphics/UI/Gtk/WebKit/WebHistoryItem.chs +++ b/Graphics/UI/Gtk/WebKit/WebHistoryItem.chs @@ -62,8 +62,8 @@ import System.Glib.FFI import System.Glib.UTFString import System.Glib.GList -import System.Glib.GError -import System.Glib.Attributes +import System.Glib.GError +import System.Glib.Attributes as G import Graphics.UI.Gtk.Gdk.Events {#import Graphics.UI.Gtk.Abstract.Object#} (makeNewObject) @@ -79,123 +79,124 @@ -- | Create a new 'WebHistoryItem' instance. -- --- A history item consists out of a title and a uri, +-- A history item consists out of a title and a uri, -- it can be part of the WebBackForwardList and the global history. -- -- The global history is used for coloring the links of visited sites. --- 'WebHistoryItem' constructed with 'webHistoryItemNew' are +-- 'WebHistoryItem' constructed with 'webHistoryItemNew' are -- automatically added to the global history. webHistoryItemNew :: IO WebHistoryItem -webHistoryItemNew = +webHistoryItemNew = wrapNewGObject mkWebHistoryItem $ {#call web_history_item_new#} -- | Create a new 'WebHistoryItem' instance with the given @uri@ and @title@. --- --- 'WebHistoryItem' constructed with 'webHistoryItemNewWithData' are +-- +-- 'WebHistoryItem' constructed with 'webHistoryItemNewWithData' are -- automatically added to the global history. -webHistoryItemNewWithData :: - String -- ^ @uri@ - the uri of the item - -> String -- ^ @title@ - the title of the item +webHistoryItemNewWithData :: + GlibString string + => string -- ^ @uri@ - the uri of the item + -> string -- ^ @title@ - the title of the item -> IO WebHistoryItem -webHistoryItemNewWithData uri title = - withCString uri $ \uriPtr -> - withCString title $ \titlePtr -> +webHistoryItemNewWithData uri title = + withUTFString uri $ \uriPtr -> + withUTFString title $ \titlePtr -> wrapNewGObject mkWebHistoryItem $ - {#call web_history_item_new_with_data#} - uriPtr + {#call web_history_item_new_with_data#} + uriPtr titlePtr -- | Return the title of 'WebHistoryItem'. -webHistoryItemGetTitle :: - WebHistoryItemClass self => self - -> IO (Maybe String) -- ^ the title or @Nothing@ in case failed. -webHistoryItemGetTitle webhistoryitem = - {#call web_history_item_get_title#} - (toWebHistoryItem webhistoryitem) >>= - maybePeek peekCString +webHistoryItemGetTitle :: + (WebHistoryItemClass self, GlibString string) => self + -> IO (Maybe string) -- ^ the title or @Nothing@ in case failed. +webHistoryItemGetTitle webhistoryitem = + {#call web_history_item_get_title#} + (toWebHistoryItem webhistoryitem) >>= + maybePeek peekUTFString -- | Return the alternate title of WebHistoryItem. -webHistoryItemGetAlternateTitle :: - WebHistoryItemClass self => self - -> IO (Maybe String) -- ^ the alternate title or @Nothing@ in case failed. -webHistoryItemGetAlternateTitle webhistoryitem = - {#call web_history_item_get_alternate_title#} - (toWebHistoryItem webhistoryitem) >>= - maybePeek peekCString +webHistoryItemGetAlternateTitle :: + (WebHistoryItemClass self, GlibString string) => self + -> IO (Maybe string) -- ^ the alternate title or @Nothing@ in case failed. +webHistoryItemGetAlternateTitle webhistoryitem = + {#call web_history_item_get_alternate_title#} + (toWebHistoryItem webhistoryitem) >>= + maybePeek peekUTFString -- | Set an alternate title for WebHistoryItem. -webHistoryItemSetAlternateTitle :: - WebHistoryItemClass self => self - -> (Maybe String) -- ^ @title@ - the alternate title for this history item. +webHistoryItemSetAlternateTitle :: + (WebHistoryItemClass self, GlibString string) => self + -> (Maybe string) -- ^ @title@ - the alternate title for this history item. -> IO() webHistoryItemSetAlternateTitle webhistoryitem title = - maybeWith withCString title $ \titlePtr -> - {#call web_history_item_set_alternate_title#} + maybeWith withUTFString title $ \titlePtr -> + {#call web_history_item_set_alternate_title#} (toWebHistoryItem webhistoryitem) titlePtr -- | Return the URI of WebHistoryItem. -webHistoryItemGetUri :: - WebHistoryItemClass self => self - -> IO (Maybe String) -- ^ the URI or @Nothing@ in case failed. -webHistoryItemGetUri webhistoryitem = - {#call web_history_item_get_uri#} - (toWebHistoryItem webhistoryitem) >>= - maybePeek peekCString +webHistoryItemGetUri :: + (WebHistoryItemClass self, GlibString string) => self + -> IO (Maybe string) -- ^ the URI or @Nothing@ in case failed. +webHistoryItemGetUri webhistoryitem = + {#call web_history_item_get_uri#} + (toWebHistoryItem webhistoryitem) >>= + maybePeek peekUTFString -- | Return the original URI of WebHistoryItem. -webHistoryItemGetOriginalUri :: - WebHistoryItemClass self => self - -> IO (Maybe String) -- ^ the URI or @Nothing@ in case failed -webHistoryItemGetOriginalUri webhistoryitem = - {#call web_history_item_get_original_uri#} - (toWebHistoryItem webhistoryitem) >>= - maybePeek peekCString +webHistoryItemGetOriginalUri :: + (WebHistoryItemClass self, GlibString string) => self + -> IO (Maybe string) -- ^ the URI or @Nothing@ in case failed +webHistoryItemGetOriginalUri webhistoryitem = + {#call web_history_item_get_original_uri#} + (toWebHistoryItem webhistoryitem) >>= + maybePeek peekUTFString -- | Return the last visited time of WebHistoryItem. -webHistoryItemGetLastVisitedTime :: - WebHistoryItemClass self => self +webHistoryItemGetLastVisitedTime :: + WebHistoryItemClass self => self -> IO Double -- ^ the last visited time of this history item. -webHistoryItemGetLastVisitedTime webhistoryitem = - liftM realToFrac $ - {#call web_history_item_get_last_visited_time#} +webHistoryItemGetLastVisitedTime webhistoryitem = + liftM realToFrac $ + {#call web_history_item_get_last_visited_time#} (toWebHistoryItem webhistoryitem) #if WEBKIT_CHECK_VERSION (1,1,18) -- | Makes a copy of the item for use with other WebView objects. -- --- * Since 1.1.18 +-- * Since 1.1.18 webHistoryItemCopy :: WebHistoryItemClass self => self -> IO WebHistoryItem webHistoryItemCopy webhistoryitem = - makeNewGObject mkWebHistoryItem $ + makeNewGObject mkWebHistoryItem $ {#call webkit_web_history_item_copy#} (toWebHistoryItem webhistoryitem) #endif -- | The title of the 'WebHistoryItem' -- -- Default value: @Nothing@ -webHistoryItemTitle :: (WebHistoryItemClass self) => ReadAttr self (Maybe String) +webHistoryItemTitle :: (WebHistoryItemClass self, GlibString string) => ReadAttr self (Maybe string) webHistoryItemTitle = readAttr webHistoryItemGetTitle -- | The alternate title of the history item. -- -- Default value: @Nothing@ -webHistoryItemAlternateTitle :: (WebHistoryItemClass self) => Attr self (Maybe String) +webHistoryItemAlternateTitle :: (WebHistoryItemClass self, GlibString string) => G.Attr self (Maybe string) webHistoryItemAlternateTitle = newAttr webHistoryItemGetAlternateTitle webHistoryItemSetAlternateTitle -- | The URI of the history item. -- -- Default value: @Nothing@ -webHistoryItemUri :: (WebHistoryItemClass self) => ReadAttr self (Maybe String) +webHistoryItemUri :: (WebHistoryItemClass self, GlibString string) => ReadAttr self (Maybe string) webHistoryItemUri = readAttr webHistoryItemGetUri -- | The original URI of the history item. -- -- Default value: @Nothing@ -webHistoryItemOriginalUri :: (WebHistoryItemClass self) => ReadAttr self (Maybe String) +webHistoryItemOriginalUri :: (WebHistoryItemClass self, GlibString string) => ReadAttr self (Maybe string) webHistoryItemOriginalUri = readAttr webHistoryItemGetOriginalUri -- | The time at which the history item was last visited. @@ -205,4 +206,4 @@ -- Default value: 0 webHistoryItemLastVisitedTime :: (WebHistoryItemClass self) => ReadAttr self Double webHistoryItemLastVisitedTime = readAttr webHistoryItemGetLastVisitedTime - + diff --git a/Graphics/UI/Gtk/WebKit/WebInspector.chs b/Graphics/UI/Gtk/WebKit/WebInspector.chs --- a/Graphics/UI/Gtk/WebKit/WebInspector.chs +++ b/Graphics/UI/Gtk/WebKit/WebInspector.chs @@ -28,7 +28,7 @@ -- | The WebKit Inspector is a graphical tool to inspect and change the content of a WebKitWebView. It -- also includes an interactive JavaScriptDebugger. Using this class one can get a 'Widget' which can -- be embedded into an application to show the inspector. --- +-- -- The inspector is available when the WebKitWebSettings of the WebKitWebView has set the -- 'enableDeveloperExtras' to true otherwise no inspector is available. @@ -45,7 +45,7 @@ webInspectorClose, #endif --- * Attribute +-- * Attribute webInspectorInspectedUri, webInspectorJSProfilingEnable, #if WEBKIT_CHECK_VERSION (1,1,17) @@ -67,8 +67,8 @@ import System.Glib.FFI import System.Glib.UTFString import System.Glib.GList -import System.Glib.GError -import System.Glib.Attributes +import System.Glib.GError +import System.Glib.Attributes as G import System.Glib.Properties import Graphics.UI.Gtk.Gdk.Events @@ -83,18 +83,18 @@ ------------------ -- | Obtains the URI that is currently being inspected -webInspectorGetInspectedUri :: - WebInspectorClass self => self - -> IO String -webInspectorGetInspectedUri inspector = - {#call web_inspector_get_inspected_uri#} (toWebInspector inspector) >>= peekCString +webInspectorGetInspectedUri :: + (WebInspectorClass self, GlibString string) => self + -> IO string +webInspectorGetInspectedUri inspector = + {#call web_inspector_get_inspected_uri#} (toWebInspector inspector) >>= peekUTFString --- | Obtains the 'WebView' that is used to render the 'WebInspector'. --- +-- | Obtains the 'WebView' that is used to render the 'WebInspector'. +-- -- The 'WebView' instance is created by the application, --- by handling the "inspect-web-view" signal. +-- by handling the "inspect-web-view" signal. -- This means that it may return @Nothing@ if the user hasn't inspected anything -webInspectorGetWebView :: +webInspectorGetWebView :: WebInspectorClass self => self -> IO (Maybe WebView) webInspectorGetWebView inspector = @@ -106,15 +106,15 @@ -- | Causes the Web Inspector to inspect the node that is located at the given coordinates of the -- widget. The coordinates should be relative to the WebKitWebView widget, not to the scrollable -- content, and may be obtained from a 'Event' directly. --- +-- -- This means x, and y being zero doesn't guarantee you will hit the left-most top corner of the -- content, since the contents may have been scrolled. --- +-- -- * Since 1.1.17 webInspectorInspectCoordinates :: WebInspectorClass self - => self -- ^ @webInspector@ the WebKitWebInspector that will do the inspection - -> Int -- ^ @x@ the X coordinate of the node to be inspected - -> Int -- ^ @y@ the Y coordinate of the node to be inspected + => self -- ^ @webInspector@ the WebKitWebInspector that will do the inspection + -> Int -- ^ @x@ the X coordinate of the node to be inspected + -> Int -- ^ @y@ the Y coordinate of the node to be inspected -> IO () webInspectorInspectCoordinates inspect x y = {#call web_inspector_inspect_coordinates#} @@ -140,26 +140,26 @@ -- * Attribute -- | The URI that is currently being inspected. -webInspectorInspectedUri :: (WebInspectorClass self) => ReadAttr self String +webInspectorInspectedUri :: (WebInspectorClass self, GlibString string) => ReadAttr self string webInspectorInspectedUri = readAttr webInspectorGetInspectedUri -- | This is enabling JavaScript profiling in the Inspector. This means that Console.profiles will return the profiles. -webInspectorJSProfilingEnable :: (WebInspectorClass self) => Attr self Bool +webInspectorJSProfilingEnable :: (WebInspectorClass self) => G.Attr self Bool webInspectorJSProfilingEnable = newAttrFromBoolProperty "javascript-profiling-enabled" #if WEBKIT_CHECK_VERSION (1,1,17) -- | This is enabling Timeline profiling in the Inspector. --- +-- -- Default value: 'False' --- +-- -- * Since 1.1.17 -webInspectorTimelineProfilingEnabled :: (WebInspectorClass self) => Attr self Bool +webInspectorTimelineProfilingEnabled :: (WebInspectorClass self) => G.Attr self Bool webInspectorTimelineProfilingEnabled = newAttrFromBoolProperty "timeline-profiling-enabled" #endif -- | The Web View that renders the Web Inspector itself. webInspectorWebView :: (WebInspectorClass self) => ReadAttr self WebView -webInspectorWebView = +webInspectorWebView = readAttrFromObjectProperty "web-view" {#call pure webkit_web_view_get_type#} @@ -173,33 +173,33 @@ -- | Emitted when the inspector should appear in a separate window. -- --- return True if the signal has been handled +-- return True if the signal has been handled detachWindow :: WebInspectorClass self => Signal self (IO Bool) detachWindow = Signal (connect_NONE__BOOL "detach_window") --- | Emitted when the inspector window should be closed. +-- | Emitted when the inspector window should be closed. -- -- return True if the signal is handled. closeWindow :: WebInspectorClass self => Signal self (IO Bool) closeWindow = Signal (connect_NONE__BOOL "close_window") --- | Emitted when the inspector window should be displayed. +-- | Emitted when the inspector window should be displayed. -- Notice that the window must have been created already by handling 'inspectWebView'. -- --- return True if the signal has been handled +-- return True if the signal has been handled showWindow :: WebInspectorClass self => Signal self (IO Bool) showWindow = Signal (connect_NONE__BOOL "show_window") --- | Emitted when the inspection is done. You should release your references on the inspector at this time. +-- | Emitted when the inspection is done. You should release your references on the inspector at this time. -- The inspected 'WebView' may no longer exist when this signal is emitted. finished :: WebInspectorClass self => Signal self (IO ()) finished = Signal (connect_NONE__NONE "finished") --- | Emitted when the user activates the 'inspect' context menu item to inspect a web view. --- The application which is interested in the inspector should create a window, +-- | Emitted when the user activates the 'inspect' context menu item to inspect a web view. +-- The application which is interested in the inspector should create a window, -- or otherwise add the 'WebView' it creates to an existing window. -- --- You don't need to handle the reference count of the 'WebView' instance you create; +-- You don't need to handle the reference count of the 'WebView' instance you create; -- the widget to which you add it will do that. inspectWebView :: WebInspectorClass self => Signal self (WebView -> IO WebView) inspectWebView = Signal (connect_OBJECT__OBJECTPTR "inspect_web_view") diff --git a/Graphics/UI/Gtk/WebKit/WebNavigationAction.chs b/Graphics/UI/Gtk/WebKit/WebNavigationAction.chs --- a/Graphics/UI/Gtk/WebKit/WebNavigationAction.chs +++ b/Graphics/UI/Gtk/WebKit/WebNavigationAction.chs @@ -85,10 +85,10 @@ -- | Returns the URI that was originally requested. -- This may differ from the navigation target, for instance because of a redirect. webNavigationActionGetOriginalUri :: - WebNavigationActionClass self => self - -> IO String + (WebNavigationActionClass self, GlibString string) => self + -> IO string webNavigationActionGetOriginalUri action = - {#call web_navigation_action_get_original_uri#} (toWebNavigationAction action) >>= peekCString + {#call web_navigation_action_get_original_uri#} (toWebNavigationAction action) >>= peekUTFString -- | Returns the reason why WebKit is requesting a navigation. webNavigationActionGetReason :: @@ -99,19 +99,19 @@ -- | Returns the target frame of the action. webNavigationActionGetTargetFrame :: - WebNavigationActionClass self => self - -> IO String + (WebNavigationActionClass self, GlibString string) => self + -> IO string webNavigationActionGetTargetFrame action = - {#call web_navigation_action_get_target_frame#} (toWebNavigationAction action) >>= peekCString + {#call web_navigation_action_get_target_frame#} (toWebNavigationAction action) >>= peekUTFString -- | Sets the URI that was originally requested. -- This may differ from the navigation target, for instance because of a redirect. webNavigationActionSetOriginalUri :: - WebNavigationActionClass self => self - -> String + (WebNavigationActionClass self, GlibString string) => self + -> string -> IO () webNavigationActionSetOriginalUri action uri = - withCString uri $ \uriPtr -> + withUTFString uri $ \uriPtr -> {#call web_navigation_action_set_original_uri#} (toWebNavigationAction action) uriPtr diff --git a/Graphics/UI/Gtk/WebKit/WebResource.chs b/Graphics/UI/Gtk/WebKit/WebResource.chs --- a/Graphics/UI/Gtk/WebKit/WebResource.chs +++ b/Graphics/UI/Gtk/WebKit/WebResource.chs @@ -40,7 +40,7 @@ -- * Constructors webResourceNew, --- * Methods +-- * Methods webResourceGetData, webResourceGetEncoding, webResourceGetFrameName, @@ -48,13 +48,14 @@ webResourceGetUri, ) where -import Control.Monad (liftM) +import Control.Monad (liftM) +import Data.ByteString (ByteString, useAsCStringLen) import System.Glib.FFI import System.Glib.UTFString import System.Glib.GList import System.Glib.GString -import System.Glib.GError +import System.Glib.GError import Graphics.UI.Gtk.Gdk.Events {#import Graphics.UI.Gtk.Abstract.Object#} (makeNewObject) @@ -63,49 +64,49 @@ {#context lib="webkit" prefix ="webkit"#} --- | Returns a new WebKitWebResource. --- The @encoding@ can be empty. +-- | Returns a new WebKitWebResource. +-- The @encoding@ can be empty. -- The @frameName@ can be used if the resource represents contents of an -- entire HTML frame, otherwise pass empty. -webResourceNew :: String -> Int -> String -> String -> String -> String -> IO WebResource -webResourceNew resData size uri mimeType encoding frameName = - withCString resData $ \dataPtr -> - withCString uri $ \uriPtr -> - withCString mimeType $ \mimePtr -> - withCString encoding $ \encodingPtr -> - withCString frameName $ \framePtr -> - wrapNewGObject mkWebResource $ +webResourceNew :: GlibString string => ByteString -> string -> string -> string -> string -> IO WebResource +webResourceNew resData uri mimeType encoding frameName = + useAsCStringLen resData $ \(dataPtr, size) -> + withUTFString uri $ \uriPtr -> + withUTFString mimeType $ \mimePtr -> + withUTFString encoding $ \encodingPtr -> + withUTFString frameName $ \framePtr -> + wrapNewGObject mkWebResource $ {#call web_resource_new#} dataPtr (fromIntegral size) uriPtr mimePtr encodingPtr framePtr -- | Returns the data of the WebResource. -webResourceGetData :: WebResourceClass self => self -> IO (Maybe String) +webResourceGetData :: WebResourceClass self => self -> IO (Maybe ByteString) webResourceGetData wr = - {#call web_resource_get_data#} (toWebResource wr) >>= readGString + {#call web_resource_get_data#} (toWebResource wr) >>= readGStringByteString -- | Get encoding. -webResourceGetEncoding :: - WebResourceClass self => self - -> IO (Maybe String) +webResourceGetEncoding :: + (WebResourceClass self, GlibString string) => self + -> IO (Maybe string) webResourceGetEncoding wr = - {#call web_resource_get_encoding#} (toWebResource wr) >>= maybePeek peekCString + {#call web_resource_get_encoding#} (toWebResource wr) >>= maybePeek peekUTFString -- | Get frame name. -webResourceGetFrameName :: - WebResourceClass self => self - -> IO (Maybe String) +webResourceGetFrameName :: + (WebResourceClass self, GlibString string) => self + -> IO (Maybe string) webResourceGetFrameName wr = - {#call web_resource_get_frame_name#} (toWebResource wr) >>= maybePeek peekCString + {#call web_resource_get_frame_name#} (toWebResource wr) >>= maybePeek peekUTFString -- | Get mime type. -webResourceGetMimeType :: - WebResourceClass self => self - -> IO (Maybe String) +webResourceGetMimeType :: + (WebResourceClass self, GlibString string) => self + -> IO (Maybe string) webResourceGetMimeType wr = - {#call web_resource_get_mime_type#} (toWebResource wr) >>= maybePeek peekCString + {#call web_resource_get_mime_type#} (toWebResource wr) >>= maybePeek peekUTFString -- | Get uri. -webResourceGetUri :: - WebResourceClass self => self - -> IO String +webResourceGetUri :: + (WebResourceClass self, GlibString string) => self + -> IO string webResourceGetUri wr = - {#call web_resource_get_uri#} (toWebResource wr) >>= peekCString + {#call web_resource_get_uri#} (toWebResource wr) >>= peekUTFString diff --git a/Graphics/UI/Gtk/WebKit/WebSettings.chs b/Graphics/UI/Gtk/WebKit/WebSettings.chs --- a/Graphics/UI/Gtk/WebKit/WebSettings.chs +++ b/Graphics/UI/Gtk/WebKit/WebSettings.chs @@ -100,9 +100,9 @@ import System.Glib.FFI import System.Glib.UTFString import System.Glib.GList -import System.Glib.GError +import System.Glib.GError import System.Glib.Properties -import System.Glib.Attributes +import System.Glib.Attributes as G import Graphics.UI.Gtk.Gdk.Events {#import Graphics.UI.Gtk.Abstract.Object#} (makeNewObject) @@ -117,158 +117,158 @@ -- | Create a new 'WebSettings' instance. --- +-- -- A 'WebSettings' can be applied to a 'WebView' --- to control the to be used text encoding, color, font size, +-- to control the to be used text encoding, color, font size, -- printing mode,script support, loading of images and various other things. webSettingsNew :: IO WebSettings -webSettingsNew = +webSettingsNew = wrapNewGObject mkWebSettings $ {#call web_settings_new#} -- | Copy an existing 'WebSettings' instance. -webSettingsCopy :: +webSettingsCopy :: WebSettingsClass self => self -> IO WebSettings -webSettingsCopy websettings = +webSettingsCopy websettings = constructNewGObject mkWebSettings $ {#call web_settings_copy#} (toWebSettings websettings) -- | Return the User-Agent string currently used. -webSettingsGetUserAgent :: - WebSettingsClass self => self - -> IO (Maybe String) -- ^ User-Agent string or @Nothing@ in case failed. -webSettingsGetUserAgent websettings = - {#call web_settings_get_user_agent#} (toWebSettings websettings) >>= maybePeek peekCString +webSettingsGetUserAgent :: + (WebSettingsClass self, GlibString string) => self + -> IO (Maybe string) -- ^ User-Agent string or @Nothing@ in case failed. +webSettingsGetUserAgent websettings = + {#call web_settings_get_user_agent#} (toWebSettings websettings) >>= maybePeek peekUTFString -- | Load images automatically -- -- Default value: True -webSettingsAutoLoadImages :: (WebSettingsClass self) => Attr self Bool +webSettingsAutoLoadImages :: (WebSettingsClass self) => G.Attr self Bool webSettingsAutoLoadImages = newAttrFromBoolProperty "auto-load-images" -- | Automatically shrink standalone images to fit -- -- Default value: True -webSettingsAutoShrinkImages :: (WebSettingsClass self) => Attr self Bool +webSettingsAutoShrinkImages :: (WebSettingsClass self) => G.Attr self Bool webSettingsAutoShrinkImages = newAttrFromBoolProperty "auto-shrink-images" -- | The default Cursive font family used to display text -- -- Default value "serif" -webSettingsCursiveFontFamily :: (WebSettingsClass self) => Attr self String +webSettingsCursiveFontFamily :: (WebSettingsClass self, GlibString string) => G.Attr self string webSettingsCursiveFontFamily = newAttrFromStringProperty "cursive-font-family" -- | The default encoding used to display text -- -- Default value "iso-8859-1" -webSettingsDefaultEncoding :: (WebSettingsClass self) => Attr self String +webSettingsDefaultEncoding :: (WebSettingsClass self, GlibString string) => G.Attr self string webSettingsDefaultEncoding = newAttrFromStringProperty "default-encoding" -- | The default font family used to display text -- -- Default value: "sans-serif" -webSettingsDefaultFontFamily :: (WebSettingsClass self) => Attr self String +webSettingsDefaultFontFamily :: (WebSettingsClass self, GlibString string) => G.Attr self string webSettingsDefaultFontFamily = newAttrFromStringProperty "default-font-family" -- | The default font size used to display text -- -- Default value: >=5 -webSettingsDefaultFontSize :: (WebSettingsClass self) => Attr self Int +webSettingsDefaultFontSize :: (WebSettingsClass self) => G.Attr self Int webSettingsDefaultFontSize = newAttrFromIntProperty "default-font-size" -- | The default font size used to display monospace text -- -- Allowed values: >= 5 --- +-- -- Default value: 10 -webSettingsDefaultMonospaceFontSize :: (WebSettingsClass self) => Attr self Int +webSettingsDefaultMonospaceFontSize :: (WebSettingsClass self) => G.Attr self Int webSettingsDefaultMonospaceFontSize = newAttrFromIntProperty "default-monospace-font-size" -- | This settings controls various editing behaviors -webSettingsEditingBehavior :: (WebSettingsClass self) => Attr self EditingBehavior +webSettingsEditingBehavior :: (WebSettingsClass self) => G.Attr self EditingBehavior webSettingsEditingBehavior = newAttrFromEnumProperty "editing-behavior" {#call pure unsafe webkit_editing_behavior_get_type#} -- | Whether to enable caret browsing mode. -webSettingsEnableCaretBrowsing :: (WebSettingsClass self) => Attr self Bool +webSettingsEnableCaretBrowsing :: (WebSettingsClass self) => G.Attr self Bool webSettingsEnableCaretBrowsing = newAttrFromBoolProperty "enable-caret-browsing" -- | Whether developer extensions should be enabled. -- -- This enables, for now, the 'WebInspector' -webSettingsEnableDeveloperExtras :: (WebSettingsClass self) => Attr self Bool +webSettingsEnableDeveloperExtras :: (WebSettingsClass self) => G.Attr self Bool webSettingsEnableDeveloperExtras = newAttrFromBoolProperty "enable-developer-extras" #if WEBKIT_CHECK_VERSION (1,1,16) -- | Whether to enable DOM paste. If set to 'True', document.execCommand("Paste") will correctly execute -- and paste content of the clipboard. --- +-- -- Default value: 'False' -- -- * Since 1.1.16 -webSettingsEnableDomPaste :: (WebSettingsClass self) => Attr self Bool +webSettingsEnableDomPaste :: (WebSettingsClass self) => G.Attr self Bool webSettingsEnableDomPaste = newAttrFromBoolProperty "enable-dom-paste" #endif -- | Whether to enable HTML5 client-side SQL database support. -webSettingsEnableHtml5Database :: (WebSettingsClass self) => Attr self Bool +webSettingsEnableHtml5Database :: (WebSettingsClass self) => G.Attr self Bool webSettingsEnableHtml5Database = newAttrFromBoolProperty "enable-html5-database" -- | Whether to enable HTML5 localStorage support. -webSettingsEnableHtml5LocalStorage :: (WebSettingsClass self) => Attr self Bool +webSettingsEnableHtml5LocalStorage :: (WebSettingsClass self) => G.Attr self Bool webSettingsEnableHtml5LocalStorage = newAttrFromBoolProperty "enable-html5-local-storage" -- | Whether to enable HTML5 offline web application cache support. -webSettingsEnableOfflineWebApplicationCache :: (WebSettingsClass self) => Attr self Bool +webSettingsEnableOfflineWebApplicationCache :: (WebSettingsClass self) => G.Attr self Bool webSettingsEnableOfflineWebApplicationCache = newAttrFromBoolProperty "enable-offline-web-application-cache" -- | Enable embedded plugin objects. -webSettingsEnablePlugins :: (WebSettingsClass self) => Attr self Bool +webSettingsEnablePlugins :: (WebSettingsClass self) => G.Attr self Bool webSettingsEnablePlugins = newAttrFromBoolProperty "enable-plugins" -- | Whether to enable private browsing mode. -webSettingsEnablePrivateBrowsing :: (WebSettingsClass self) => Attr self Bool +webSettingsEnablePrivateBrowsing :: (WebSettingsClass self) => G.Attr self Bool webSettingsEnablePrivateBrowsing = newAttrFromBoolProperty "enable-private-browsing" -- | Enable embedded scripting languages -webSettingsEnableScripts :: (WebSettingsClass self) => Attr self Bool +webSettingsEnableScripts :: (WebSettingsClass self) => G.Attr self Bool webSettingsEnableScripts = newAttrFromBoolProperty "enable-scripts" -- | Whether to enable speel checking while typing. -webSettingsEnableSpellChecking :: (WebSettingsClass self) => Attr self Bool +webSettingsEnableSpellChecking :: (WebSettingsClass self) => G.Attr self Bool webSettingsEnableSpellChecking = newAttrFromBoolProperty "enable-spell-checking" -- | Whether to allow files loaded through file:// URLs universal access to all pages. -webSettingsEnableUniversalAccessFromFileUris :: (WebSettingsClass self) => Attr self Bool +webSettingsEnableUniversalAccessFromFileUris :: (WebSettingsClass self) => G.Attr self Bool webSettingsEnableUniversalAccessFromFileUris = newAttrFromBoolProperty "enable-universal-access-from-file-uris" -- | Whether to enable the XSS Auditor. -- -- This feature filters some kinds of reflective XSS attacks on vulnerable web sites. -webSettingsEnableXssAuditor :: (WebSettingsClass self) => Attr self Bool +webSettingsEnableXssAuditor :: (WebSettingsClass self) => G.Attr self Bool webSettingsEnableXssAuditor = newAttrFromBoolProperty "enable-xss-auditor" -- | Enforce a resolution of 96 DPI. -webSettingsEnforce96Dpi :: (WebSettingsClass self) => Attr self Bool +webSettingsEnforce96Dpi :: (WebSettingsClass self) => G.Attr self Bool webSettingsEnforce96Dpi = newAttrFromBoolProperty "enforce-96-dpi" -- | The default Fantasy font family used to display text -webSettingsFantasyFontFamily :: (WebSettingsClass self) => Attr self String +webSettingsFantasyFontFamily :: (WebSettingsClass self, GlibString string) => G.Attr self string webSettingsFantasyFontFamily = newAttrFromStringProperty "fantasy-font-family" -- | Whether JavaScript can open popup windows automatically without user intervention. -webSettingsJSCanOpenWindowAuto :: (WebSettingsClass self) => Attr self Bool +webSettingsJSCanOpenWindowAuto :: (WebSettingsClass self) => G.Attr self Bool webSettingsJSCanOpenWindowAuto = newAttrFromBoolProperty "javascript-can-open-windows-automatically" -- | The minimum font size used to display text. --- +-- -- Allowed values: >=1 -- -- Default value: 5 -webSettingsMinimumFontSize :: (WebSettingsClass self) => Attr self Int +webSettingsMinimumFontSize :: (WebSettingsClass self) => G.Attr self Int webSettingsMinimumFontSize = newAttrFromIntProperty "minimum-font-size" -- | The minimum logical font size used to display text @@ -276,65 +276,65 @@ -- Allowed values: >=1 -- -- Default value: 5 -webSettingsMinimumLogicalFontSize :: (WebSettingsClass self) => Attr self Int +webSettingsMinimumLogicalFontSize :: (WebSettingsClass self) => G.Attr self Int webSettingsMinimumLogicalFontSize = newAttrFromIntProperty "minimum-logical-font-size" -- | The default font family used to display monospace text. --- +-- -- Default value: "monospace" -webSettingsMonospaceFontFamily :: (WebSettingsClass self) => Attr self String +webSettingsMonospaceFontFamily :: (WebSettingsClass self, GlibString string) => G.Attr self string webSettingsMonospaceFontFamily = newAttrFromStringProperty "monospace-font-family" -- | Whether background images should be printed -- -- Default value: True -webSettingsPrintBackgrounds :: (WebSettingsClass self) => Attr self Bool +webSettingsPrintBackgrounds :: (WebSettingsClass self) => G.Attr self Bool webSettingsPrintBackgrounds = newAttrFromBoolProperty "print-backgrounds" -- | Whether text areas are resizable -- -- Default value : True -webSettingsResizableTextAreas :: (WebSettingsClass self) => Attr self Bool +webSettingsResizableTextAreas :: (WebSettingsClass self) => G.Attr self Bool webSettingsResizableTextAreas = newAttrFromBoolProperty "resizable-text-areas" -- | The default Sans Serif font family used to display text --- +-- -- Default value "sans-serif" -webSettingsSansFontFamily :: (WebSettingsClass self) => Attr self String +webSettingsSansFontFamily :: (WebSettingsClass self, GlibString string) => G.Attr self string webSettingsSansFontFamily = newAttrFromStringProperty "sans-serif-font-family" -- | The default Serif font family used to display text -- -- Default value: "serif" -webSettingsSerifFontFamily :: (WebSettingsClass self) => Attr self String +webSettingsSerifFontFamily :: (WebSettingsClass self, GlibString string) => G.Attr self string webSettingsSerifFontFamily = newAttrFromStringProperty "serif-font-family" -- | The languages to be used for spell checking, separated by commas --- +-- -- The locale string typically is in the form lang_COUNTRY, --- where lang is an ISO-639 language code, and COUNTRY is an ISO-3166 country code. +-- where lang is an ISO-639 language code, and COUNTRY is an ISO-3166 country code. -- For instance, sv_FI for Swedish as written in Finland or pt_BR for Portuguese as written in Brazil. -- -- If no value is specified then the value returned by gtk_get_default_language will be used. -- -- Default value: @Nothing@ -webSettingsSpellCheckingLang :: (WebSettingsClass self) => Attr self (Maybe String) +webSettingsSpellCheckingLang :: (WebSettingsClass self, GlibString string) => G.Attr self (Maybe string) webSettingsSpellCheckingLang = newAttrFromMaybeStringProperty "spell-checking-languages" #if WEBKIT_CHECK_VERSION (1,1,17) -- | Whether the tab key cycles through elements on the page. --- +-- -- If flag is 'True', pressing the tab key will focus the next element in the @webView@. If flag is 'False', -- the @webView@ will interpret tab key presses as normal key presses. If the selected element is -- editable, the tab key will cause the insertion of a tab character. --- +-- -- Default value: 'True' -- -- * Since 1.1.17 -webSettingsTabKeyCyclesThroughElements :: (WebSettingsClass self) => Attr self Bool +webSettingsTabKeyCyclesThroughElements :: (WebSettingsClass self) => G.Attr self Bool webSettingsTabKeyCyclesThroughElements = newAttrFromBoolProperty "tab-key-cycles-through-elements" #endif @@ -343,11 +343,11 @@ -- menu. Turning this off will make WebKitGTK+ not emit the populate-popup signal. Notice that the -- default button press event handler may still handle right clicks for other reasons, such as in-page -- context menus, or right-clicks that are handled by the page itself. --- +-- -- Default value: 'True' --- +-- -- * Since 1.1.18 -webSettingsEnableDefaultContextMenu :: (WebSettingsClass self) => Attr self Bool +webSettingsEnableDefaultContextMenu :: (WebSettingsClass self) => G.Attr self Bool webSettingsEnableDefaultContextMenu = newAttrFromBoolProperty "enable-default-context-menu" -- | Enable or disable the page cache. Disabling the page cache is generally only useful for special @@ -356,30 +356,30 @@ -- memory-based traditional resource caches, its point is to make going back and forth between pages -- much faster. For details about the different types of caches and their purposes see: -- http://webkit.org/ blog/427/webkit-page-cache-i-the-basics/ --- +-- -- Default value: 'False' --- +-- -- * Since 1.1.18 -webSettingsEnablePageCache :: (WebSettingsClass self) => Attr self Bool +webSettingsEnablePageCache :: (WebSettingsClass self) => G.Attr self Bool webSettingsEnablePageCache = newAttrFromBoolProperty "enable-page-cache" #endif -- | The User-Agent string used by WebKit --- --- This will return a default User-Agent string if a custom string wasn't provided by the application. --- Setting this property to a NULL value or an empty string will result in +-- +-- This will return a default User-Agent string if a custom string wasn't provided by the application. +-- Setting this property to a NULL value or an empty string will result in -- the User-Agent string being reset to the default value. -- -- Default value: \"Mozilla/5.0 (X11; U; Linux x86_64; c) AppleWebKit/531.2+ (KHTML, like Gecko) Safari/531.2+\" -webSettingsUserAgent :: (WebSettingsClass self) => Attr self String +webSettingsUserAgent :: (WebSettingsClass self, GlibString string) => G.Attr self string webSettingsUserAgent = newAttrFromStringProperty "user-agent" -- | The URI of a stylesheet that is applied to every page. -- -- Default value: @Nothing@ -webSettingsUserStylesheetUri :: (WebSettingsClass self) => Attr self (Maybe String) +webSettingsUserStylesheetUri :: (WebSettingsClass self, GlibString string) => G.Attr self (Maybe string) webSettingsUserStylesheetUri = newAttrFromMaybeStringProperty "user-stylesheet-uri" -- | The value by which the zoom level is changed when zooming in or out @@ -387,13 +387,13 @@ -- Allowed values: >= 0 -- -- Default value: 0.1 -webSettingsZoomStep :: (WebSettingsClass self) => Attr self Float +webSettingsZoomStep :: (WebSettingsClass self) => G.Attr self Float webSettingsZoomStep = newAttrFromFloatProperty "zoom-step" - + -- | Enables the site-specific compatibility workarounds. -- -- Default value: False -webSettingsEnableSiteSpecificQuirks :: WebSettingsClass self => Attr self Bool +webSettingsEnableSiteSpecificQuirks :: WebSettingsClass self => G.Attr self Bool webSettingsEnableSiteSpecificQuirks = newAttrFromBoolProperty "enable-site-specific-quirks" #if WEBKIT_CHECK_VERSION (1,1,23) @@ -402,10 +402,10 @@ -- Down arrow keys. For example, if an user presses the Right key, heuristics determine whether there -- is an element he might be trying to reach towards the right, and if there are multiple elements, -- which element he probably wants. --- +-- -- Default value: 'False' --- +-- -- * Since 1.1.23 -webSettingsEnableSpatialNavigation :: WebSettingsClass self => Attr self Bool +webSettingsEnableSpatialNavigation :: WebSettingsClass self => G.Attr self Bool webSettingsEnableSpatialNavigation = newAttrFromBoolProperty "enable-spatial-navigation" #endif diff --git a/Graphics/UI/Gtk/WebKit/WebView.chs b/Graphics/UI/Gtk/WebKit/WebView.chs --- a/Graphics/UI/Gtk/WebKit/WebView.chs +++ b/Graphics/UI/Gtk/WebKit/WebView.chs @@ -1,4 +1,5 @@ -{-# LANGUAGE CPP #-} +{-# LANGUAGE CPP #-} +{-# LANGUAGE ViewPatterns #-} -- -*-haskell-*- ----------------------------------------------------------------------------- -- Module : Graphics.UI.Gtk.WebKit.WebView @@ -182,7 +183,9 @@ #endif -- * Attributes +#if WEBKIT_CHECK_VERSION(1,0,1) webViewZoomLevel, +#endif webViewFullContentZoom, webViewEncoding, webViewCustomEncoding, @@ -206,6 +209,10 @@ webViewImContext, #endif +#if WEBKIT_CHECK_VERSION(1,3,4) + webViewViewMode, +#endif + -- * Signals -- ** Loading loadStarted, @@ -261,12 +268,13 @@ undo, ) where -import Control.Monad (liftM, (<=<)) +import Control.Monad (liftM, (<=<)) +import Data.ByteString (ByteString, useAsCString) import System.Glib.FFI import System.Glib.UTFString import System.Glib.GList -import System.Glib.Attributes +import System.Glib.Attributes as G import System.Glib.Properties import System.Glib.GError import Graphics.UI.Gtk.Gdk.Events @@ -330,7 +338,7 @@ -- | Obtains the URI for the favicon for the given WebKitWebView, or 'Nothing' if there is none. -- -- * Since 1.1.18 -webViewGetIconUri :: WebViewClass self => self -> IO (Maybe String) +webViewGetIconUri :: (WebViewClass self, GlibString string) => self -> IO (Maybe string) webViewGetIconUri webview = {#call webkit_web_view_get_icon_uri #} (toWebView webview) >>= maybePeek peekUTFString @@ -368,8 +376,8 @@ #if WEBKIT_CHECK_VERSION(1,1,1) -- | Requests loading of the specified URI string in a 'WebView' -webViewLoadUri :: WebViewClass self => self -> String -> IO () -webViewLoadUri webview url = withCString url $ {#call web_view_load_uri#} (toWebView webview) +webViewLoadUri :: (WebViewClass self, GlibString string) => self -> string -> IO () +webViewLoadUri webview url = withUTFString url $ {#call web_view_load_uri#} (toWebView webview) #endif -- | Determine whether 'WebView' has a previous history item. @@ -455,10 +463,10 @@ #if WEBKIT_CHECK_VERSION (1,0,3) -- | Returns whether or not a @mimetype@ can be displayed using this view. -webViewCanShowMimeType :: WebViewClass self => self - -> String -- ^ @mimetype@ - a MIME type +webViewCanShowMimeType :: (WebViewClass self, GlibString string) => self + -> string -- ^ @mimetype@ - a MIME type -> IO Bool -- ^ True if the @mimetype@ can be displayed, otherwise False -webViewCanShowMimeType webview mime = withCString mime $ liftM toBool . {#call web_view_can_show_mime_type#} (toWebView webview) +webViewCanShowMimeType webview mime = withUTFString mime $ liftM toBool . {#call web_view_can_show_mime_type#} (toWebView webview) #endif -- | Returns whether the user is allowed to edit the document. @@ -471,11 +479,11 @@ #if WEBKIT_CHECK_VERSION(1,3,4) -- | Gets the value of the "view-mode" property of the 'WebView' -webViewGetViewMode :: WebView -> IO ViewMode -webViewGetViewMode = liftM (toEnum . fromIntegral) . {#call web_view_get_view_source_mode#} +webViewGetViewMode :: WebViewClass self => self -> IO ViewMode +webViewGetViewMode = liftM (toEnum . fromIntegral) . {#call web_view_get_view_source_mode#} . toWebView -webViewSetViewMode :: WebView -> ViewMode -> IO () -webViewSetViewMode webView viewMode = {#call web_view_set_view_source_mode#} webView (fromIntegral . fromEnum $ viewMode) +webViewSetViewMode :: WebViewClass self => self -> ViewMode -> IO () +webViewSetViewMode (toWebView -> webView) viewMode = {#call web_view_set_view_source_mode#} webView (fromIntegral . fromEnum $ viewMode) #endif -- | Returns whether 'WebView' is in view source mode @@ -534,27 +542,46 @@ -- | Loading the @content@ string as html. The URI passed in base_uri has to be an absolute URI. -- Deprecated since webkit v1.1.1, use 'webViewLoadString' instead. -webViewLoadHtmlString :: WebViewClass self => self - -> String -- ^ @content@ - the html string - -> String -- ^ @base_uri@ - the base URI +webViewLoadHtmlString :: (WebViewClass self, GlibString string) => self + -> string -- ^ @content@ - the html string + -> string -- ^ @base_uri@ - the base URI -> IO() -webViewLoadHtmlString webview htmlstr url = withCString htmlstr $ \htmlPtr -> withCString url $ \urlPtr -> +webViewLoadHtmlString webview htmlstr url = withUTFString htmlstr $ \htmlPtr -> withUTFString url $ \urlPtr -> {#call web_view_load_html_string#} (toWebView webview) htmlPtr urlPtr +-- | Requests loading of the given @content@ with the specified @mime_type@ and @base_uri@. +-- If @mime_type@ is @Nothing@, "text/html" is assumed. +-- If want control over the encoding use `webViewLoadByteString` +webViewLoadString :: (WebViewClass self, GlibString string) => self + -> string -- ^ @content@ - the content string to be loaded. + -> (Maybe string) -- ^ @mime_type@ - the MIME type or @Nothing@. + -> string -- ^ @base_uri@ - the base URI for relative locations. + -> IO () +webViewLoadString webview content mimetype baseuri = + withUTFString content $ \contentPtr -> + maybeWith withUTFString mimetype $ \mimetypePtr -> + withUTFString baseuri $ \baseuriPtr -> + {#call web_view_load_string#} + (toWebView webview) + contentPtr + mimetypePtr + nullPtr + baseuriPtr + -- | Requests loading of the given @content@ with the specified @mime_type@, @encoding@ and @base_uri@. -- If @mime_type@ is @Nothing@, "text/html" is assumed. -- If @encoding@ is @Nothing@, "UTF-8" is assumed. -webViewLoadString :: WebViewClass self => self - -> String -- ^ @content@ - the content string to be loaded. - -> (Maybe String) -- ^ @mime_type@ - the MIME type or @Nothing@. - -> (Maybe String) -- ^ @encoding@ - the encoding or @Nothing@. - -> String -- ^ @base_uri@ - the base URI for relative locations. +webViewLoadByteString :: (WebViewClass self, GlibString string) => self + -> ByteString -- ^ @content@ - the content string to be loaded. + -> (Maybe string) -- ^ @mime_type@ - the MIME type or @Nothing@. + -> (Maybe string) -- ^ @encoding@ - the encoding or @Nothing@. + -> string -- ^ @base_uri@ - the base URI for relative locations. -> IO () -webViewLoadString webview content mimetype encoding baseuri = - withCString content $ \contentPtr -> - maybeWith withCString mimetype $ \mimetypePtr -> - maybeWith withCString encoding $ \encodingPtr -> - withCString baseuri $ \baseuriPtr -> +webViewLoadByteString webview content mimetype encoding baseuri = + useAsCString content $ \contentPtr -> + maybeWith withUTFString mimetype $ \mimetypePtr -> + maybeWith withUTFString encoding $ \encodingPtr -> + withUTFString baseuri $ \baseuriPtr -> {#call web_view_load_string#} (toWebView webview) contentPtr @@ -564,11 +591,11 @@ #if WEBKIT_CHECK_VERSION(1,1,4) -- | Returns the title of 'WebView' document, or Nothing in case of failure -webViewGetTitle :: WebViewClass self => self -> IO (Maybe String) +webViewGetTitle :: (WebViewClass self, GlibString string) => self -> IO (Maybe string) webViewGetTitle = maybePeek peekUTFString <=< {#call web_view_get_title#} . toWebView -- | Returns the current URI of the contents displayed by the 'WebView', or Nothing in case of failure -webViewGetUri :: WebViewClass self => self -> IO (Maybe String) +webViewGetUri :: (WebViewClass self, GlibString string) => self -> IO (Maybe string) webViewGetUri = maybePeek peekUTFString <=< {#call web_view_get_uri#} . toWebView #endif @@ -594,14 +621,14 @@ webViewZoomOut = {#call web_view_zoom_out#} . toWebView -- | Looks for a specified string inside 'WebView' -webViewSearchText :: WebViewClass self => self - -> String -- ^ @text@ - a string to look for +webViewSearchText :: (WebViewClass self, GlibString string) => self + -> string -- ^ @text@ - a string to look for -> Bool -- ^ @case_sensitive@ - whether to respect the case of text -> Bool -- ^ @forward@ - whether to find forward or not -> Bool -- ^ @wrap@ - whether to continue looking at beginning after reaching the end -> IO Bool -- ^ True on success or False on failure webViewSearchText webview text case_sensitive forward wrap = - withCString text $ \textPtr -> + withUTFString text $ \textPtr -> liftM toBool $ {#call web_view_search_text#} (toWebView webview) @@ -611,12 +638,12 @@ (fromBool wrap) -- | Attempts to highlight all occurances of string inside 'WebView' -webViewMarkTextMatches :: WebViewClass self => self - -> String -- ^ @string@ - a string to look for +webViewMarkTextMatches :: (WebViewClass self, GlibString string) => self + -> string -- ^ @string@ - a string to look for -> Bool -- ^ @case_sensitive@ - whether to respect the case of text -> Int -- ^ @limit@ - the maximum number of strings to look for or 0 for all -> IO Int -- ^ the number of strings highlighted -webViewMarkTextMatches webview text case_sensitive limit = withCString text $ \textPtr -> liftM fromIntegral $ +webViewMarkTextMatches webview text case_sensitive limit = withUTFString text $ \textPtr -> liftM fromIntegral $ {#call web_view_mark_text_matches#} (toWebView webview) textPtr (fromBool case_sensitive) (fromIntegral limit) -- | Move the cursor in view as described by step and count. @@ -636,10 +663,10 @@ {#call web_view_set_highlight_text_matches#} (toWebView webview) (fromBool highlight) -- | Execute the script specified by @script@ -webViewExecuteScript :: WebViewClass self => self - -> String -- ^ @script@ - script to be executed +webViewExecuteScript :: (WebViewClass self, GlibString string) => self + -> string -- ^ @script@ - script to be executed -> IO() -webViewExecuteScript webview script = withCString script $ {#call web_view_execute_script#} (toWebView webview) +webViewExecuteScript webview script = withUTFString script $ {#call web_view_execute_script#} (toWebView webview) -- | Determines whether can cuts the current selection inside 'WebView' to the clipboard webViewCanCutClipboard :: WebViewClass self => self -> IO Bool @@ -700,24 +727,24 @@ #endif -- | Returns the default encoding of the 'WebView' -webViewGetEncoding :: WebViewClass self => self - -> IO (Maybe String) -- ^ the default encoding or @Nothing@ in case of failed +webViewGetEncoding :: (WebViewClass self, GlibString string) => self + -> IO (Maybe string) -- ^ the default encoding or @Nothing@ in case of failed webViewGetEncoding webview = {#call web_view_get_encoding#} (toWebView webview) >>= maybePeek peekUTFString #if WEBKIT_CHECK_VERSION(1,1,1) -- | Sets the current 'WebView' encoding, -- without modifying the default one, and reloads the page -webViewSetCustomEncoding :: WebViewClass self => self - -> (Maybe String) -- ^ @encoding@ - the new encoding, or @Nothing@ to restore the default encoding. +webViewSetCustomEncoding :: (WebViewClass self, GlibString string) => self + -> (Maybe string) -- ^ @encoding@ - the new encoding, or @Nothing@ to restore the default encoding. -> IO () webViewSetCustomEncoding webview encoding = - maybeWith withCString encoding $ \encodingPtr -> + maybeWith withUTFString encoding $ \encodingPtr -> {#call web_view_set_custom_encoding#} (toWebView webview) encodingPtr #endif -- | Returns the current encoding of 'WebView',not the default encoding. -webViewGetCustomEncoding :: WebViewClass self => self - -> IO (Maybe String) -- ^ the current encoding string or @Nothing@ if there is none set. +webViewGetCustomEncoding :: (WebViewClass self, GlibString string) => self + -> IO (Maybe string) -- ^ the current encoding string or @Nothing@ if there is none set. webViewGetCustomEncoding = maybePeek peekUTFString <=< {#call web_view_get_custom_encoding#} . toWebView #if WEBKIT_CHECK_VERSION(1,1,7) @@ -747,49 +774,47 @@ -- * Attibutes +#if WEBKIT_CHECK_VERSION(1,0,1) -- | Zoom level of the 'WebView' instance -webViewZoomLevel :: WebViewClass self => Attr self Float -webViewZoomLevel = newAttr - webViewGetZoomLevel - webViewSetZoomLevel +webViewZoomLevel :: WebViewClass self => G.Attr self Float +webViewZoomLevel = newAttrFromFloatProperty "zoom-level" +#endif -- | Whether the full content is scaled when zooming -- -- Default value: False -webViewFullContentZoom :: WebViewClass self => Attr self Bool -webViewFullContentZoom = newAttr - webViewGetFullContentZoom - webViewSetFullContentZoom +webViewFullContentZoom :: WebViewClass self => G.Attr self Bool +webViewFullContentZoom = newAttrFromBoolProperty "full-content-zoom" -- | The default encoding of the 'WebView' instance -- -- Default value: @Nothing@ -webViewEncoding :: WebViewClass self => ReadAttr self (Maybe String) -webViewEncoding = readAttr webViewGetEncoding +webViewEncoding :: (WebViewClass self, GlibString string) => ReadAttr self (Maybe string) +webViewEncoding = readAttrFromMaybeStringProperty "encoding" -- | Determines the current status of the load. -- -- Default value: @LoadFinished@ webViewLoadStatus :: WebViewClass self => ReadAttr self LoadStatus -webViewLoadStatus = readAttr webViewGetLoadStatus +webViewLoadStatus = readAttrFromEnumProperty "load-status" {#call pure unsafe webkit_load_status_get_type#} -- |Determines the current progress of the load -- -- Default Value: 1 webViewProgress :: WebViewClass self => ReadAttr self Double -webViewProgress = readAttr webViewGetProgress +webViewProgress = readAttrFromDoubleProperty "progress" -- | The associated webSettings of the 'WebView' instance -webViewWebSettings :: WebViewClass self => Attr self WebSettings +webViewWebSettings :: WebViewClass self => G.Attr self WebSettings webViewWebSettings = newAttr webViewGetWebSettings webViewSetWebSettings -- | Title of the 'WebView' instance -webViewTitle :: WebViewClass self => ReadAttr self (Maybe String) -webViewTitle = readAttr webViewGetTitle +webViewTitle :: (WebViewClass self, GlibString string) => ReadAttr self (Maybe string) +webViewTitle = readAttrFromMaybeStringProperty "title" -- | The associated webInspector instance of the 'WebView' webViewInspector :: WebViewClass self => ReadAttr self WebInspector @@ -799,36 +824,30 @@ -- | The custom encoding of the 'WebView' instance -- -- Default value: @Nothing@ -webViewCustomEncoding :: WebViewClass self => Attr self (Maybe String) -webViewCustomEncoding = newAttr - webViewGetCustomEncoding - webViewSetCustomEncoding +webViewCustomEncoding :: (WebViewClass self, GlibString string) => G.Attr self (Maybe string) +webViewCustomEncoding = newAttrFromMaybeStringProperty "custom-encoding" -- | view source mode of the 'WebView' instance -webViewViewSourceMode :: WebViewClass self => Attr self Bool +webViewViewSourceMode :: WebViewClass self => G.Attr self Bool webViewViewSourceMode = newAttr webViewGetViewSourceMode webViewSetViewSourceMode -- | transparent background of the 'WebView' instance -webViewTransparent :: WebViewClass self => Attr self Bool -webViewTransparent = newAttr - webViewGetTransparent - webViewSetTransparent +webViewTransparent :: WebViewClass self => G.Attr self Bool +webViewTransparent = newAttrFromBoolProperty "transparent" -- | Whether content of the 'WebView' can be modified by the user -- -- Default value: @False@ -webViewEditable :: WebViewClass self => Attr self Bool -webViewEditable = newAttr - webViewGetEditable - webViewSetEditable +webViewEditable :: WebViewClass self => G.Attr self Bool +webViewEditable = newAttrFromBoolProperty "editable" -- | Returns the current URI of the contents displayed by the @web_view@. -- -- Default value: Nothing -webViewUri :: WebViewClass self => ReadAttr self (Maybe String) -webViewUri = readAttr webViewGetUri +webViewUri :: (WebViewClass self, GlibString string) => ReadAttr self (Maybe string) +webViewUri = readAttrFromMaybeStringProperty "uri" -- | The list of targets this web view supports for clipboard copying. webViewCopyTargetList :: WebViewClass self => ReadAttr self (Maybe TargetList) @@ -839,7 +858,7 @@ webViewPasteTargetList = readAttr webViewGetPasteTargetList -- | An associated 'WebWindowFeatures' instance. -webViewWindowFeatures :: WebViewClass self => Attr self WebWindowFeatures +webViewWindowFeatures :: WebViewClass self => G.Attr self WebWindowFeatures webViewWindowFeatures = newAttrFromObjectProperty "window-features" {#call pure webkit_web_window_features_get_type#} @@ -850,8 +869,8 @@ -- Default value: 'Nothing' -- -- * Since 1.1.18 -webViewIconUri :: WebViewClass self => ReadAttr self String -webViewIconUri = readAttrFromStringProperty "icon-uri" +webViewIconUri :: (WebViewClass self, GlibString string) => ReadAttr self (Maybe string) +webViewIconUri = readAttrFromMaybeStringProperty "icon-uri" #endif #if WEBKIT_CHECK_VERSION (1,1,20) @@ -867,6 +886,13 @@ {#call pure gtk_im_context_get_type #} #endif +#if WEBKIT_CHECK_VERSION(1,3,4) +-- | The "view-mode" property of the 'WebView' +webViewViewMode :: (WebViewClass self) => G.Attr self ViewMode +webViewViewMode = newAttr + webViewGetViewMode + webViewSetViewMode +#endif #if WEBKIT_CHECK_VERSION (1,3,1) webViewGetDomDocument :: WebView -> IO (Maybe Document) @@ -905,8 +931,8 @@ -- webframe - which 'WebFrame' changes the document title. -- -- title - current title string. -titleChanged :: WebViewClass self => Signal self ( WebFrame -> String -> IO() ) -titleChanged = Signal (connect_OBJECT_STRING__NONE "title_changed") +titleChanged :: (WebViewClass self, GlibString string) => Signal self ( WebFrame -> string -> IO() ) +titleChanged = Signal (connect_OBJECT_GLIBSTRING__NONE "title_changed") -- | When the cursor is over a link, this signal is emitted. @@ -914,8 +940,8 @@ -- title - the link's title or @Nothing@ in case of failure. -- -- uri - the URI the link points to or @Nothing@ in case of failure. -hoveringOverLink :: WebViewClass self => Signal self (Maybe String -> Maybe String -> IO()) -hoveringOverLink = Signal (connect_MSTRING_MSTRING__NONE "hovering_over_link") +hoveringOverLink :: (WebViewClass self, GlibString string) => Signal self (Maybe string -> Maybe string -> IO()) +hoveringOverLink = Signal (connect_MGLIBSTRING_MGLIBSTRING__NONE "hovering_over_link") -- | When a 'WebFrame' begins to load, this signal is emitted loadStarted :: WebViewClass self => Signal self (WebFrame -> IO()) @@ -945,8 +971,8 @@ -- if you want to provide your own error page. -- -- The URI that triggered the error and the 'GError' will be passed back to user function. -loadError :: WebViewClass self => Signal self (WebFrame -> String -> GError -> IO Bool) -loadError = Signal (connect_OBJECT_STRING_BOXED__BOOL "load_error" peek) +loadError :: (WebViewClass self, GlibString string) => Signal self (WebFrame -> string -> GError -> IO Bool) +loadError = Signal (connect_OBJECT_GLIBSTRING_BOXED__BOOL "load_error" peek) createWebView :: WebViewClass self => Signal self (WebFrame -> IO WebView) createWebView = Signal (connect_OBJECT__OBJECTPTR "create_web_view") @@ -965,8 +991,8 @@ #endif -- | A JavaScript console message was created. -consoleMessage :: WebViewClass self => Signal self (String -> String -> Int -> String -> IO Bool) -consoleMessage = Signal (connect_STRING_STRING_INT_STRING__BOOL "console_message") +consoleMessage :: (WebViewClass self, GlibString string) => Signal self (string -> string -> Int -> string -> IO Bool) +consoleMessage = Signal (connect_GLIBSTRING_GLIBSTRING_INT_GLIBSTRING__BOOL "console_message") -- | The 'copyClipboard' signal is a keybinding signal which gets emitted to copy the selection to the clipboard. -- @@ -1000,20 +1026,20 @@ printRequested = Signal (connect_OBJECT__BOOL "print_requested") -- | A JavaScript alert dialog was created. -scriptAlert :: WebViewClass self => Signal self (WebFrame -> String -> IO Bool) -scriptAlert = Signal (connect_OBJECT_STRING__BOOL "script_alert") +scriptAlert :: (WebViewClass self, GlibString string) => Signal self (WebFrame -> string -> IO Bool) +scriptAlert = Signal (connect_OBJECT_GLIBSTRING__BOOL "script_alert") -- | A JavaScript confirm dialog was created, providing Yes and No buttons. -scriptConfirm :: WebViewClass self => Signal self (WebFrame -> String -> IO Bool) -scriptConfirm = Signal (connect_OBJECT_STRING__BOOL "script_confirm") +scriptConfirm :: (WebViewClass self, GlibString string) => Signal self (WebFrame -> string -> IO Bool) +scriptConfirm = Signal (connect_OBJECT_GLIBSTRING__BOOL "script_confirm") -- | A JavaScript prompt dialog was created, providing an entry to input text. -scriptPrompt :: WebViewClass self => Signal self (WebFrame -> String -> String -> IO Bool) -scriptPrompt = Signal (connect_OBJECT_STRING_STRING__BOOL "script_prompt") +scriptPrompt :: (WebViewClass self, GlibString string) => Signal self (WebFrame -> string -> string -> IO Bool) +scriptPrompt = Signal (connect_OBJECT_GLIBSTRING_GLIBSTRING__BOOL "script_prompt") -- | When status-bar text changed, this signal will emitted. -statusBarTextChanged :: WebViewClass self => Signal self (String -> IO ()) -statusBarTextChanged = Signal (connect_STRING__NONE "status_bar_text_changed") +statusBarTextChanged :: (WebViewClass self, GlibString string) => Signal self (string -> IO ()) +statusBarTextChanged = Signal (connect_GLIBSTRING__NONE "status_bar_text_changed") editingBegan :: WebViewClass self => Signal self (IO ()) @@ -1071,9 +1097,9 @@ #if WEBKIT_CHECK_VERSION (1,1,18) -- | Emitted after Icon loaded -iconLoaded :: WebViewClass self => Signal self (String -> IO ()) +iconLoaded :: (WebViewClass self, GlibString string) => Signal self (string -> IO ()) iconLoaded = - Signal (connect_STRING__NONE "icon_loaded") + Signal (connect_GLIBSTRING__NONE "icon_loaded") #endif -- | The "redo" signal is a keybinding signal which gets emitted to redo the last editing command. @@ -1099,8 +1125,8 @@ -- see also soupMessageHeadersGetContentDisposition' -- And you must call 'webPolicyDecisionIgnore', 'webPolicyDecisionDownload', or 'webPolicyDecisionUse' -- on the 'webPolicyDecision' object. -mimeTypePolicyDecisionRequested :: WebViewClass self => Signal self (WebFrame -> NetworkRequest -> String -> WebPolicyDecision -> IO Bool) -mimeTypePolicyDecisionRequested = Signal (connect_OBJECT_OBJECT_STRING_OBJECT__BOOL "mime_type_policy_decision_requested") +mimeTypePolicyDecisionRequested :: (WebViewClass self, GlibString string) => Signal self (WebFrame -> NetworkRequest -> string -> WebPolicyDecision -> IO Bool) +mimeTypePolicyDecisionRequested = Signal (connect_OBJECT_OBJECT_GLIBSTRING_OBJECT__BOOL "mime_type_policy_decision_requested") -- | The 'moveCursor' will be emitted to apply the cursor movement described by its parameters to the view. moveCursor :: WebViewClass self => Signal self (MovementStep -> Int -> IO Bool) diff --git a/Graphics/UI/Gtk/WebKit/WebWindowFeatures.chs b/Graphics/UI/Gtk/WebKit/WebWindowFeatures.chs --- a/Graphics/UI/Gtk/WebKit/WebWindowFeatures.chs +++ b/Graphics/UI/Gtk/WebKit/WebWindowFeatures.chs @@ -29,7 +29,7 @@ -- include the x, y position of the window, the width and height but also if a toolbar, scrollbar, -- statusbar, locationbar should be visible to the user, the request to show the WebKitWebView -- fullscreen. --- +-- -- In the normal case one will use 'webViewGetWindowFeatures' to get the -- WebKitWebWindowFeatures and then monitor the property changes. Be aware that the -- WebKitWebWindowFeatures might change change before 'webViewReady' signal is emitted. To be safe @@ -43,7 +43,7 @@ -- * Constructors webWindowFeaturesNew, --- * Methods +-- * Methods webWindowFeaturesEqual, -- * Attributes @@ -64,8 +64,8 @@ import System.Glib.FFI import System.Glib.UTFString import System.Glib.GList -import System.Glib.GError -import System.Glib.Attributes +import System.Glib.GError +import System.Glib.Attributes as G import System.Glib.Properties import Graphics.UI.Gtk.Gdk.Events @@ -77,14 +77,14 @@ -- * Constructors --- | Creates a new 'WebWindowFeatures' instance with default values. +-- | Creates a new 'WebWindowFeatures' instance with default values. -- It must be manually attached to a WebView. webWindowFeaturesNew :: IO WebWindowFeatures -webWindowFeaturesNew = +webWindowFeaturesNew = wrapNewGObject mkWebWindowFeatures $ {#call web_window_features_new#} -- | Decides if a 'WebWindowFeatures' instance equals another, as in has the same values. -webWindowFeaturesEqual :: +webWindowFeaturesEqual :: (WebWindowFeaturesClass winA, WebWindowFeaturesClass winB) => winA -> winB -> IO Bool webWindowFeaturesEqual winA winB = @@ -93,42 +93,42 @@ -- * Attributes -- | Controls whether window will be displayed fullscreen. -webWindowFeaturesFullscreen :: WebWindowFeaturesClass self => Attr self Bool +webWindowFeaturesFullscreen :: WebWindowFeaturesClass self => G.Attr self Bool webWindowFeaturesFullscreen = newAttrFromBoolProperty "fullscreen" -- | The height of the window on the screen. -webWindowFeaturesHeight :: WebWindowFeaturesClass self => Attr self Int +webWindowFeaturesHeight :: WebWindowFeaturesClass self => G.Attr self Int webWindowFeaturesHeight = newAttrFromIntProperty "height" -- | The width of the window on the screen. -webWindowFeaturesWidth :: WebWindowFeaturesClass self => Attr self Int +webWindowFeaturesWidth :: WebWindowFeaturesClass self => G.Attr self Int webWindowFeaturesWidth = newAttrFromIntProperty "width" -- | Controls whether the locationbar should be visible for the window. -webWindowFeaturesLocationbarVisible :: WebWindowFeaturesClass self => Attr self Bool +webWindowFeaturesLocationbarVisible :: WebWindowFeaturesClass self => G.Attr self Bool webWindowFeaturesLocationbarVisible = newAttrFromBoolProperty "locationbar-visible" -- | Controls whether the menubar should be visible for the window. -webWindowFeaturesMenubarVisible :: WebWindowFeaturesClass self => Attr self Bool +webWindowFeaturesMenubarVisible :: WebWindowFeaturesClass self => G.Attr self Bool webWindowFeaturesMenubarVisible = newAttrFromBoolProperty "menubar-visible" -- | Controls whether the scrollbar should be visible for the window. -webWindowFeaturesScrollbarVisible :: WebWindowFeaturesClass self => Attr self Bool +webWindowFeaturesScrollbarVisible :: WebWindowFeaturesClass self => G.Attr self Bool webWindowFeaturesScrollbarVisible = newAttrFromBoolProperty "scrollbar-visible" -- | Controls whether the statusbar should be visible for the window. -webWindowFeaturesStatusbarVisible :: WebWindowFeaturesClass self => Attr self Bool +webWindowFeaturesStatusbarVisible :: WebWindowFeaturesClass self => G.Attr self Bool webWindowFeaturesStatusbarVisible = newAttrFromBoolProperty "statusbar-visible" -- | Controls whether the toolbar should be visible for the window. -webWindowFeaturesToolbarVisible :: WebWindowFeaturesClass self => Attr self Bool +webWindowFeaturesToolbarVisible :: WebWindowFeaturesClass self => G.Attr self Bool webWindowFeaturesToolbarVisible = newAttrFromBoolProperty "toolbar-visible" -- | The starting x position of the window on the screen. -webWindowFeaturesX :: WebWindowFeaturesClass self => Attr self Int +webWindowFeaturesX :: WebWindowFeaturesClass self => G.Attr self Int webWindowFeaturesX = newAttrFromIntProperty "x" -- | The starting y position of the window on the screen. -webWindowFeaturesY :: WebWindowFeaturesClass self => Attr self Int +webWindowFeaturesY :: WebWindowFeaturesClass self => G.Attr self Int webWindowFeaturesY = newAttrFromIntProperty "y" diff --git a/Gtk2HsSetup.hs b/Gtk2HsSetup.hs deleted file mode 100644 --- a/Gtk2HsSetup.hs +++ /dev/null @@ -1,487 +0,0 @@ -{-# LANGUAGE CPP, ViewPatterns #-} - -#ifndef CABAL_VERSION_CHECK -#error This module has to be compiled via the Setup.hs program which generates the gtk2hs-macros.h file -#endif - --- | Build a Gtk2hs package. --- -module Gtk2HsSetup ( - gtk2hsUserHooks, - getPkgConfigPackages, - checkGtk2hsBuildtools, - typeGenProgram, - signalGenProgram, - c2hsLocal - ) where - -import Distribution.Simple -import Distribution.Simple.PreProcess -import Distribution.InstalledPackageInfo ( importDirs, - showInstalledPackageInfo, - libraryDirs, - extraLibraries, - extraGHCiLibraries ) -import Distribution.Simple.PackageIndex ( lookupInstalledPackageId ) -import Distribution.PackageDescription as PD ( PackageDescription(..), - updatePackageDescription, - BuildInfo(..), - emptyBuildInfo, allBuildInfo, - Library(..), - libModules, hasLibs) -import Distribution.Simple.LocalBuildInfo (LocalBuildInfo(withPackageDB, buildDir, localPkgDescr, installedPkgs, withPrograms), - InstallDirs(..), - componentPackageDeps, - absoluteInstallDirs) -import Distribution.Simple.Compiler ( Compiler(..) ) -import Distribution.Simple.Program ( - Program(..), ConfiguredProgram(..), - rawSystemProgramConf, rawSystemProgramStdoutConf, programName, programPath, - c2hsProgram, pkgConfigProgram, gccProgram, requireProgram, ghcPkgProgram, - simpleProgram, lookupProgram, rawSystemProgramStdout, ProgArg) -import Distribution.ModuleName ( ModuleName, components, toFilePath ) -import Distribution.Simple.Utils -import Distribution.Simple.Setup (CopyFlags(..), InstallFlags(..), CopyDest(..), - defaultCopyFlags, ConfigFlags(configVerbosity), - fromFlag, toFlag, RegisterFlags(..), flagToMaybe, - fromFlagOrDefault, defaultRegisterFlags) -import Distribution.Simple.BuildPaths ( autogenModulesDir ) -import Distribution.Simple.Install ( install ) -import Distribution.Simple.Register ( generateRegistrationInfo, registerPackage ) -import Distribution.Text ( simpleParse, display ) -import System.FilePath -import System.Exit (exitFailure) -import System.Directory ( doesFileExist, getDirectoryContents, doesDirectoryExist ) -import Distribution.Version (Version(..)) -import Distribution.Verbosity -import Control.Monad (when, unless, filterM, liftM, forM, forM_) -import Data.Maybe ( isJust, isNothing, fromMaybe, maybeToList, catMaybes ) -import Data.List (isPrefixOf, isSuffixOf, stripPrefix, nub, tails ) -import Data.Char (isAlpha, isNumber) -import qualified Data.Map as M -import qualified Data.Set as S -import qualified Distribution.Simple.LocalBuildInfo as LBI -import Distribution.Simple.Compiler (compilerVersion) - -import Control.Applicative ((<$>)) - -#if CABAL_VERSION_CHECK(1,17,0) -import Distribution.Simple.Program.Find ( defaultProgramSearchPath ) -onDefaultSearchPath f a b = f a b defaultProgramSearchPath -libraryConfig lbi = case [clbi | (LBI.CLibName, clbi, _) <- LBI.componentsConfigs lbi] of - [clbi] -> Just clbi - _ -> Nothing -#else -onDefaultSearchPath = id -libraryConfig = LBI.libraryConfig -#endif - --- the name of the c2hs pre-compiled header file -precompFile = "precompchs.bin" - -gtk2hsUserHooks = simpleUserHooks { - hookedPrograms = [typeGenProgram, signalGenProgram, c2hsLocal], - hookedPreProcessors = [("chs", ourC2hs)], - confHook = \pd cf -> - (fmap adjustLocalBuildInfo (confHook simpleUserHooks pd cf)), - postConf = \args cf pd lbi -> do - genSynthezisedFiles (fromFlag (configVerbosity cf)) pd lbi - postConf simpleUserHooks args cf pd lbi, - buildHook = \pd lbi uh bf -> fixDeps pd >>= \pd -> - buildHook simpleUserHooks pd lbi uh bf, - copyHook = \pd lbi uh flags -> copyHook simpleUserHooks pd lbi uh flags >> - installCHI pd lbi (fromFlag (copyVerbosity flags)) (fromFlag (copyDest flags)), - instHook = \pd lbi uh flags -> -#if defined(mingw32_HOST_OS) || defined(__MINGW32__) - installHook pd lbi uh flags >> - installCHI pd lbi (fromFlag (installVerbosity flags)) NoCopyDest, - regHook = registerHook -#else - instHook simpleUserHooks pd lbi uh flags >> - installCHI pd lbi (fromFlag (installVerbosity flags)) NoCopyDest -#endif - } - ------------------------------------------------------------------------------- --- Lots of stuff for windows ghci support ------------------------------------------------------------------------------- - -getDlls :: [FilePath] -> IO [FilePath] -getDlls dirs = filter ((== ".dll") . takeExtension) . concat <$> - mapM getDirectoryContents dirs - -fixLibs :: [FilePath] -> [String] -> [String] -fixLibs dlls = concatMap $ \ lib -> - case filter (isLib lib) dlls of - dll:_ -> [dropExtension dll] - _ -> if lib == "z" then [] else [lib] - where - isLib lib dll = - case stripPrefix ("lib"++lib) dll of - Just ('.':_) -> True - Just ('-':n:_) | isNumber n -> True - _ -> False - --- The following code is a big copy-and-paste job from the sources of --- Cabal 1.8 just to be able to fix a field in the package file. Yuck. - -installHook :: PackageDescription -> LocalBuildInfo - -> UserHooks -> InstallFlags -> IO () -installHook pkg_descr localbuildinfo _ flags = do - let copyFlags = defaultCopyFlags { - copyDistPref = installDistPref flags, - copyDest = toFlag NoCopyDest, - copyVerbosity = installVerbosity flags - } - install pkg_descr localbuildinfo copyFlags - let registerFlags = defaultRegisterFlags { - regDistPref = installDistPref flags, - regInPlace = installInPlace flags, - regPackageDB = installPackageDB flags, - regVerbosity = installVerbosity flags - } - when (hasLibs pkg_descr) $ register pkg_descr localbuildinfo registerFlags - -registerHook :: PackageDescription -> LocalBuildInfo - -> UserHooks -> RegisterFlags -> IO () -registerHook pkg_descr localbuildinfo _ flags = - if hasLibs pkg_descr - then register pkg_descr localbuildinfo flags - else setupMessage verbosity - "Package contains no library to register:" (packageId pkg_descr) - where verbosity = fromFlag (regVerbosity flags) - -register :: PackageDescription -> LocalBuildInfo - -> RegisterFlags -- ^Install in the user's database?; verbose - -> IO () -register pkg@(library -> Just lib ) - lbi@(libraryConfig -> Just clbi) regFlags - = do - - installedPkgInfoRaw <- generateRegistrationInfo - verbosity pkg lib lbi clbi inplace distPref - - dllsInScope <- getSearchPath >>= (filterM doesDirectoryExist) >>= getDlls - let libs = fixLibs dllsInScope (extraLibraries installedPkgInfoRaw) - installedPkgInfo = installedPkgInfoRaw { - extraGHCiLibraries = libs } - - -- Three different modes: - case () of - _ | modeGenerateRegFile -> die "Generate Reg File not supported" - | modeGenerateRegScript -> die "Generate Reg Script not supported" - | otherwise -> registerPackage verbosity - installedPkgInfo pkg lbi inplace -#if CABAL_VERSION_CHECK(1,10,0) - packageDbs -#else - packageDb -#endif - - where - modeGenerateRegFile = isJust (flagToMaybe (regGenPkgConf regFlags)) - modeGenerateRegScript = fromFlag (regGenScript regFlags) - inplace = fromFlag (regInPlace regFlags) - packageDbs = nub $ withPackageDB lbi - ++ maybeToList (flagToMaybe (regPackageDB regFlags)) - packageDb = registrationPackageDB packageDbs - distPref = fromFlag (regDistPref regFlags) - verbosity = fromFlag (regVerbosity regFlags) - -register _ _ regFlags = notice verbosity "No package to register" - where - verbosity = fromFlag (regVerbosity regFlags) - - ------------------------------------------------------------------------------- --- This is a hack for Cabal-1.8, It is not needed in Cabal-1.9.1 or later ------------------------------------------------------------------------------- - -adjustLocalBuildInfo :: LocalBuildInfo -> LocalBuildInfo -adjustLocalBuildInfo lbi = - let extra = (Just libBi, []) - libBi = emptyBuildInfo { includeDirs = [ autogenModulesDir lbi - , buildDir lbi ] } - in lbi { localPkgDescr = updatePackageDescription extra (localPkgDescr lbi) } - ------------------------------------------------------------------------------- --- Processing .chs files with our local c2hs. ------------------------------------------------------------------------------- - -ourC2hs :: BuildInfo -> LocalBuildInfo -> PreProcessor -ourC2hs bi lbi = PreProcessor { - platformIndependent = False, - runPreProcessor = runC2HS bi lbi -} - -runC2HS :: BuildInfo -> LocalBuildInfo -> - (FilePath, FilePath) -> (FilePath, FilePath) -> Verbosity -> IO () -runC2HS bi lbi (inDir, inFile) (outDir, outFile) verbosity = do - -- have the header file name if we don't have the precompiled header yet - header <- case lookup "x-c2hs-header" (customFieldsBI bi) of - Just h -> return h - Nothing -> die ("Need x-c2hs-Header definition in the .cabal Library section "++ - "that sets the C header file to process .chs.pp files.") - - -- c2hs will output files in out dir, removing any leading path of the input file. - -- Thus, append the dir of the input file to the output dir. - let (outFileDir, newOutFile) = splitFileName outFile - let newOutDir = outDir outFileDir - -- additional .chi files might be needed that other packages have installed; - -- we assume that these are installed in the same place as .hi files - let chiDirs = [ dir | - ipi <- maybe [] (map fst . componentPackageDeps) (libraryConfig lbi), - dir <- maybe [] importDirs (lookupInstalledPackageId (installedPkgs lbi) ipi) ] - (gccProg, _) <- requireProgram verbosity gccProgram (withPrograms lbi) - rawSystemProgramConf verbosity c2hsLocal (withPrograms lbi) $ - map ("--include=" ++) (outDir:chiDirs) - ++ [ "--cpp=" ++ programPath gccProg, "--cppopts=-E" ] - ++ ["--cppopts=" ++ opt | opt <- getCppOptions bi lbi] - ++ ["--output-dir=" ++ newOutDir, - "--output=" ++ newOutFile, - "--precomp=" ++ buildDir lbi precompFile, - header, inDir inFile] - -getCppOptions :: BuildInfo -> LocalBuildInfo -> [String] -getCppOptions bi lbi - = nub $ - ["-I" ++ dir | dir <- PD.includeDirs bi] - ++ [opt | opt@('-':c:_) <- PD.cppOptions bi ++ PD.ccOptions bi, c `elem` "DIU"] - ++ ["-D__GLASGOW_HASKELL__="++show (ghcDefine . ghcVersion . compilerId $ LBI.compiler lbi)] - where - ghcDefine (v1:v2:_) = v1 * 100 + v2 - ghcDefine _ = __GLASGOW_HASKELL__ - - ghcVersion :: CompilerId -> [Int] --- This version is nicer, but we need to know the Cabal version that includes the new CompilerId --- #if CABAL_VERSION_CHECK(1,19,2) --- ghcVersion (CompilerId GHC v _) = versionBranch v --- ghcVersion (CompilerId _ _ (Just c)) = ghcVersion c --- #else --- ghcVersion (CompilerId GHC v) = versionBranch v --- #endif --- ghcVersion _ = [] --- This version should work fine for now - ghcVersion = concat . take 1 . map (read . (++"]") . takeWhile (/=']')) . catMaybes - . map (stripPrefix "CompilerId GHC (Version {versionBranch = ") . tails . show - -installCHI :: PackageDescription -- ^information from the .cabal file - -> LocalBuildInfo -- ^information from the configure step - -> Verbosity -> CopyDest -- ^flags sent to copy or install - -> IO () -installCHI pkg@PD.PackageDescription { library = Just lib } lbi verbosity copydest = do - let InstallDirs { libdir = libPref } = absoluteInstallDirs pkg lbi copydest - -- cannot use the recommended 'findModuleFiles' since it fails if there exists - -- a modules that does not have a .chi file - mFiles <- mapM (findFileWithExtension' ["chi"] [buildDir lbi] . toFilePath) - (PD.libModules lib) - - let files = [ f | Just f <- mFiles ] - installOrdinaryFiles verbosity libPref files - - -installCHI _ _ _ _ = return () - ------------------------------------------------------------------------------- --- Generating the type hierarchy and signal callback .hs files. ------------------------------------------------------------------------------- - -typeGenProgram :: Program -typeGenProgram = simpleProgram "gtk2hsTypeGen" - -signalGenProgram :: Program -signalGenProgram = simpleProgram "gtk2hsHookGenerator" - -c2hsLocal :: Program -c2hsLocal = (simpleProgram "gtk2hsC2hs") { - programFindVersion = findProgramVersion "--version" $ \str -> - -- Invoking "gtk2hsC2hs --version" gives a string like: - -- C->Haskell Compiler, version 0.13.4 (gtk2hs branch) "Bin IO", 13 Nov 2004 - case words str of - (_:_:_:ver:_) -> ver - _ -> "" - } - - -genSynthezisedFiles :: Verbosity -> PackageDescription -> LocalBuildInfo -> IO () -genSynthezisedFiles verb pd lbi = do - cPkgs <- getPkgConfigPackages verb lbi pd - - let xList = maybe [] (customFieldsBI . libBuildInfo) (library pd) - ++customFieldsPD pd - typeOpts :: String -> [ProgArg] - typeOpts tag = concat [ map (\val -> '-':'-':drop (length tag) field ++ '=':val) (words content) - | (field,content) <- xList, - tag `isPrefixOf` field, - field /= (tag++"file")] - ++ [ "--tag=" ++ tag - | PackageIdentifier name (Version (major:minor:_) _) <- cPkgs - , let name' = filter isAlpha (display name) - , tag <- name' - :[ name' ++ "-" ++ show maj ++ "." ++ show d2 - | (maj, d2) <- [(maj, d2) | maj <- [0..(major-1)], d2 <- [0,2..20]] - ++ [(major, d2) | d2 <- [0,2..minor]] ] - ] - - signalsOpts :: [ProgArg] - signalsOpts = concat [ map (\val -> '-':'-':drop 10 field++'=':val) (words content) - | (field,content) <- xList, - "x-signals-" `isPrefixOf` field, - field /= "x-signals-file"] - - genFile :: Program -> [ProgArg] -> FilePath -> IO () - genFile prog args outFile = do - res <- rawSystemProgramStdoutConf verb prog (withPrograms lbi) args - rewriteFile outFile res - - forM_ (filter (\(tag,_) -> "x-types-" `isPrefixOf` tag && "file" `isSuffixOf` tag) xList) $ - \(fileTag, f) -> do - let tag = reverse (drop 4 (reverse fileTag)) - info verb ("Ensuring that class hierarchy in "++f++" is up-to-date.") - genFile typeGenProgram (typeOpts tag) f - - case lookup "x-signals-file" xList of - Nothing -> return () - Just f -> do - info verb ("Ensuring that callback hooks in "++f++" are up-to-date.") - genFile signalGenProgram signalsOpts f - - writeFile "gtk2hs_macros.h" $ generateMacros cPkgs - --- Based on Cabal/Distribution/Simple/Build/Macros.hs -generateMacros :: [PackageId] -> String -generateMacros cPkgs = concat $ - "/* DO NOT EDIT: This file is automatically generated by Gtk2HsSetup.hs */\n\n" : - [ concat - ["/* package ",display pkgid," */\n" - ,"#define VERSION_",pkgname," ",show (display version),"\n" - ,"#define MIN_VERSION_",pkgname,"(major1,major2,minor) (\\\n" - ," (major1) < ",major1," || \\\n" - ," (major1) == ",major1," && (major2) < ",major2," || \\\n" - ," (major1) == ",major1," && (major2) == ",major2," && (minor) <= ",minor,")" - ,"\n\n" - ] - | pkgid@(PackageIdentifier name version) <- cPkgs - , let (major1:major2:minor:_) = map show (versionBranch version ++ repeat 0) - pkgname = map fixchar (display name) - ] - where fixchar '-' = '_' - fixchar '.' = '_' - fixchar c = c - ---FIXME: Cabal should tell us the selected pkg-config package versions in the --- LocalBuildInfo or equivalent. --- In the mean time, ask pkg-config again. - -getPkgConfigPackages :: Verbosity -> LocalBuildInfo -> PackageDescription -> IO [PackageId] -getPkgConfigPackages verbosity lbi pkg = - sequence - [ do version <- pkgconfig ["--modversion", display pkgname] - case simpleParse version of - Nothing -> die "parsing output of pkg-config --modversion failed" - Just v -> return (PackageIdentifier pkgname v) - | Dependency pkgname _ <- concatMap pkgconfigDepends (allBuildInfo pkg) ] - where - pkgconfig = rawSystemProgramStdoutConf verbosity - pkgConfigProgram (withPrograms lbi) - ------------------------------------------------------------------------------- --- Dependency calculation amongst .chs files. ------------------------------------------------------------------------------- - --- Given all files of the package, find those that end in .chs and extract the --- .chs files they depend upon. Then return the PackageDescription with these --- files rearranged so that they are built in a sequence that files that are --- needed by other files are built first. -fixDeps :: PackageDescription -> IO PackageDescription -fixDeps pd@PD.PackageDescription { - PD.library = Just lib@PD.Library { - PD.exposedModules = expMods, - PD.libBuildInfo = bi@PD.BuildInfo { - PD.hsSourceDirs = srcDirs, - PD.otherModules = othMods - }}} = do - let findModule m = findFileWithExtension [".chs.pp",".chs"] srcDirs - (joinPath (components m)) - mExpFiles <- mapM findModule expMods - mOthFiles <- mapM findModule othMods - - -- tag all exposed files with True so we throw an error if we need to build - -- an exposed module before an internal modules (we cannot express this) - let modDeps = zipWith (ModDep True []) expMods mExpFiles++ - zipWith (ModDep False []) othMods mOthFiles - modDeps <- mapM extractDeps modDeps - let (expMods, othMods) = span mdExposed $ sortTopological modDeps - badOther = map (fromMaybe "" . mdLocation) $ - filter (not . mdExposed) expMods - unless (null badOther) $ - die ("internal chs modules "++intercalate "," badOther++ - " depend on exposed chs modules; cabal needs to build internal modules first") - return pd { PD.library = Just lib { - PD.exposedModules = map mdOriginal expMods, - PD.libBuildInfo = bi { PD.otherModules = map mdOriginal othMods } - }} - -data ModDep = ModDep { - mdExposed :: Bool, - mdRequires :: [ModuleName], - mdOriginal :: ModuleName, - mdLocation :: Maybe FilePath -} - -instance Show ModDep where - show x = show (mdLocation x) - -instance Eq ModDep where - ModDep { mdOriginal = m1 } == ModDep { mdOriginal = m2 } = m1==m2 -instance Ord ModDep where - compare ModDep { mdOriginal = m1 } ModDep { mdOriginal = m2 } = compare m1 m2 - --- Extract the dependencies of this file. This is intentionally rather naive as it --- ignores CPP conditionals. We just require everything which means that the --- existance of a .chs module may not depend on some CPP condition. -extractDeps :: ModDep -> IO ModDep -extractDeps md@ModDep { mdLocation = Nothing } = return md -extractDeps md@ModDep { mdLocation = Just f } = withUTF8FileContents f $ \con -> do - let findImports acc (('{':'#':xs):xxs) = case (dropWhile (' ' ==) xs) of - ('i':'m':'p':'o':'r':'t':' ':ys) -> - case simpleParse (takeWhile ('#' /=) ys) of - Just m -> findImports (m:acc) xxs - Nothing -> die ("cannot parse chs import in "++f++":\n"++ - "offending line is {#"++xs) - -- no more imports after the first non-import hook - _ -> return acc - findImports acc (_:xxs) = findImports acc xxs - findImports acc [] = return acc - mods <- findImports [] (lines con) - return md { mdRequires = mods } - --- Find a total order of the set of modules that are partially sorted by their --- dependencies on each other. The function returns the sorted list of modules --- together with a list of modules that are required but not supplied by this --- in the input set of modules. -sortTopological :: [ModDep] -> [ModDep] -sortTopological ms = reverse $ fst $ foldl visit ([], S.empty) (map mdOriginal ms) - where - set = M.fromList (map (\m -> (mdOriginal m, m)) ms) - visit (out,visited) m - | m `S.member` visited = (out,visited) - | otherwise = case m `M.lookup` set of - Nothing -> (out, m `S.insert` visited) - Just md -> (md:out', visited') - where - (out',visited') = foldl visit (out, m `S.insert` visited) (mdRequires md) - --- Check user whether install gtk2hs-buildtools correctly. -checkGtk2hsBuildtools :: [Program] -> IO () -checkGtk2hsBuildtools programs = do - programInfos <- mapM (\ prog -> do - location <- onDefaultSearchPath programFindLocation prog normal - return (programName prog, location) - ) programs - let printError name = do - putStrLn $ "Cannot find " ++ name ++ "\n" - ++ "Please install `gtk2hs-buildtools` first and check that the install directory is in your PATH (e.g. HOME/.cabal/bin)." - exitFailure - forM_ programInfos $ \ (name, location) -> - when (isNothing location) (printError name) diff --git a/Setup.hs b/Setup.hs --- a/Setup.hs +++ b/Setup.hs @@ -1,10 +1,12 @@ --- Standard setup file for a Gtk2Hs module. +-- Adjustments specific to this package, +-- all Gtk2Hs-specific boilerplate is kept in +-- gtk2hs-buildtools:Gtk2HsSetup -- --- See also: --- * SetupMain.hs : the real Setup script for this package --- * Gtk2HsSetup.hs : Gtk2Hs-specific boilerplate --- * SetupWrapper.hs : wrapper for compat with various ghc/cabal versions +import Gtk2HsSetup ( gtk2hsUserHooks, checkGtk2hsBuildtools, + typeGenProgram, signalGenProgram, c2hsLocal) +import Distribution.Simple ( defaultMainWithHooks ) -import SetupWrapper ( setupWrapper ) +main = do + checkGtk2hsBuildtools [typeGenProgram, signalGenProgram, c2hsLocal] + defaultMainWithHooks gtk2hsUserHooks -main = setupWrapper "SetupMain.hs" diff --git a/SetupMain.hs b/SetupMain.hs deleted file mode 100644 --- a/SetupMain.hs +++ /dev/null @@ -1,13 +0,0 @@ --- The real Setup file for a Gtk2Hs package (invoked via the SetupWrapper). --- It contains only adjustments specific to this package, --- all Gtk2Hs-specific boilerplate is kept in Gtk2HsSetup.hs --- which should be kept identical across all packages. --- -import Gtk2HsSetup ( gtk2hsUserHooks, checkGtk2hsBuildtools, - typeGenProgram, signalGenProgram, c2hsLocal) -import Distribution.Simple ( defaultMainWithHooks ) - -main = do - checkGtk2hsBuildtools [typeGenProgram, signalGenProgram, c2hsLocal] - defaultMainWithHooks gtk2hsUserHooks - diff --git a/SetupWrapper.hs b/SetupWrapper.hs deleted file mode 100644 --- a/SetupWrapper.hs +++ /dev/null @@ -1,164 +0,0 @@ --- A wrapper script for Cabal Setup.hs scripts. Allows compiling the real Setup --- conditionally depending on the Cabal version. - -module SetupWrapper (setupWrapper) where - -import Distribution.Package -import Distribution.Compiler -import Distribution.Simple.Utils -import Distribution.Simple.Program -import Distribution.Simple.Compiler -import Distribution.Simple.BuildPaths (exeExtension) -import Distribution.Simple.Configure (configCompiler) -import Distribution.Simple.GHC (getInstalledPackages) -import qualified Distribution.Simple.PackageIndex as PackageIndex -import Distribution.Version -import Distribution.Verbosity -import Distribution.Text - -import System.Environment -import System.Process -import System.Exit -import System.FilePath -import System.Directory -import qualified Control.Exception as Exception -import System.IO.Error (isDoesNotExistError) - -import Data.List -import Data.Char -import Control.Monad - - --- moreRecentFile is implemented in Distribution.Simple.Utils, but only in --- Cabal >= 1.18. For backwards-compatibility, we implement a copy with a new --- name here. Some desirable alternate strategies don't work: --- * We can't use CPP to check which version of Cabal we're up against because --- this is the file that's generating the macros for doing that. --- * We can't use the name moreRecentFiles and use --- import D.S.U hiding (moreRecentFiles) --- because on old GHC's (and according to the Report) hiding a name that --- doesn't exist is an error. -moreRecentFile' :: FilePath -> FilePath -> IO Bool -moreRecentFile' a b = do - exists <- doesFileExist b - if not exists - then return True - else do tb <- getModificationTime b - ta <- getModificationTime a - return (ta > tb) - -setupWrapper :: FilePath -> IO () -setupWrapper setupHsFile = do - args <- getArgs - createDirectoryIfMissingVerbose verbosity True setupDir - compileSetupExecutable - invokeSetupScript args - - where - setupDir = "dist/setup-wrapper" - setupVersionFile = setupDir "setup" <.> "version" - setupProgFile = setupDir "setup" <.> exeExtension - setupMacroFile = setupDir "wrapper-macros.h" - - useCabalVersion = Version [1,8] [] - usePackageDB = [GlobalPackageDB, UserPackageDB] - verbosity = normal - - cabalLibVersionToUse comp conf = do - savedVersion <- savedCabalVersion - case savedVersion of - Just version - -> return version - _ -> do version <- installedCabalVersion comp conf - writeFile setupVersionFile (show version ++ "\n") - return version - - savedCabalVersion = do - versionString <- readFile setupVersionFile - `Exception.catch` \e -> if isDoesNotExistError e - then return "" - else Exception.throwIO e - case reads versionString of - [(version,s)] | all isSpace s -> return (Just version) - _ -> return Nothing - - installedCabalVersion comp conf = do - index <- getInstalledPackages verbosity usePackageDB conf - - let cabalDep = Dependency (PackageName "Cabal") - (orLaterVersion useCabalVersion) - case PackageIndex.lookupDependency index cabalDep of - [] -> die $ "The package requires Cabal library version " - ++ display useCabalVersion - ++ " but no suitable version is installed." - pkgs -> return $ bestVersion (map fst pkgs) - where - bestVersion = maximumBy (comparing preference) - preference version = (sameVersion, sameMajorVersion - ,stableVersion, latestVersion) - where - sameVersion = version == cabalVersion - sameMajorVersion = majorVersion version == majorVersion cabalVersion - majorVersion = take 2 . versionBranch - stableVersion = case versionBranch version of - (_:x:_) -> even x - _ -> False - latestVersion = version - - -- | If the Setup.hs is out of date wrt the executable then recompile it. - -- Currently this is GHC only. It should really be generalised. - -- - compileSetupExecutable = do - setupHsNewer <- setupHsFile `moreRecentFile'` setupProgFile - cabalVersionNewer <- setupVersionFile `moreRecentFile'` setupProgFile - let outOfDate = setupHsNewer || cabalVersionNewer - when outOfDate $ do - debug verbosity "Setup script is out of date, compiling..." - - (comp, conf) <- configCompiler (Just GHC) Nothing Nothing - defaultProgramConfiguration verbosity - cabalLibVersion <- cabalLibVersionToUse comp conf - let cabalPkgid = PackageIdentifier (PackageName "Cabal") cabalLibVersion - debug verbosity $ "Using Cabal library version " ++ display cabalLibVersion - - writeFile setupMacroFile (generateVersionMacro cabalLibVersion) - - rawSystemProgramConf verbosity ghcProgram conf $ - ["--make", setupHsFile, "-o", setupProgFile] - ++ ghcPackageDbOptions usePackageDB - ++ ["-package", display cabalPkgid - ,"-cpp", "-optP-include", "-optP" ++ setupMacroFile - ,"-odir", setupDir, "-hidir", setupDir] - where - - ghcPackageDbOptions dbstack = case dbstack of - (GlobalPackageDB:UserPackageDB:dbs) -> concatMap specific dbs - (GlobalPackageDB:dbs) -> "-no-user-package-conf" - : concatMap specific dbs - _ -> ierror - where - specific (SpecificPackageDB db) = [ "-package-conf", db ] - specific _ = ierror - ierror = error "internal error: unexpected package db stack" - - generateVersionMacro :: Version -> String - generateVersionMacro version = - concat - ["/* DO NOT EDIT: This file is automatically generated by Cabal */\n\n" - ,"#define CABAL_VERSION_CHECK(major1,major2,minor) (\\\n" - ," (major1) < ",major1," || \\\n" - ," (major1) == ",major1," && (major2) < ",major2," || \\\n" - ," (major1) == ",major1," && (major2) == ",major2," && (minor) <= ",minor,")" - ,"\n\n" - ] - where - (major1:major2:minor:_) = map show (versionBranch version ++ repeat 0) - - invokeSetupScript :: [String] -> IO () - invokeSetupScript args = do - info verbosity $ unwords (setupProgFile : args) - process <- runProcess (currentDir setupProgFile) args - Nothing Nothing - Nothing Nothing Nothing - exitCode <- waitForProcess process - unless (exitCode == ExitSuccess) $ exitWith exitCode diff --git a/demo/Webkit.hs b/demo/Webkit.hs --- a/demo/Webkit.hs +++ b/demo/Webkit.hs @@ -14,13 +14,17 @@ -- module Main where -import Graphics.UI.Gtk -import Graphics.UI.Gtk.WebKit.WebView -import Graphics.UI.Gtk.WebKit.WebFrame +import Control.Monad.Trans -import System.Process -import System.Environment +import Data.Text +import Graphics.UI.Gtk +import Graphics.UI.Gtk.WebKit.WebFrame +import Graphics.UI.Gtk.WebKit.WebView + +import System.Environment +import System.Process + -- | Main entry. main :: IO () main = do @@ -46,7 +50,7 @@ window <- windowNew windowSetDefaultSize window 900 600 windowSetPosition window WinPosCenter - windowSetOpacity window 0.8 -- this function need window-manager support Alpha channel in X11 + set window [windowOpacity := 0.8] -- this function need window-manager support Alpha channel in X11 -- Create WebKit view. webView <- webViewNew @@ -65,23 +69,23 @@ entrySetText addressBar url -- Open uri when user press `return` at address bar. - onEntryActivate addressBar $ do - uri <- entryGetText addressBar -- get uri from address bar - webViewLoadUri webView uri -- load new uri + addressBar `on` entryActivated $ do + uri <- entryGetText addressBar -- get uri from address bar + webViewLoadUri webView (uri :: Text) -- load new uri - -- Add current uri to address bar when load start. - webView `on` loadStarted $ \frame -> do + -- Add current uri to address bar when load is committed. + webView `on` loadCommitted $ \frame -> do currentUri <- webFrameGetUri frame case currentUri of - Just uri -> entrySetText addressBar uri - Nothing -> return () + Just uri -> entrySetText addressBar (uri :: Text) + _ -> return () -- Open all link in current window. webView `on` createWebView $ \frame -> do newUri <- webFrameGetUri frame case newUri of - Just uri -> webViewLoadUri webView uri - Nothing -> return () + Just uri -> webViewLoadUri webView (uri :: Text) + _ -> return () return webView -- Connect and show. @@ -89,7 +93,7 @@ boxPackStart winBox scrollWin PackGrow 0 window `containerAdd` winBox scrollWin `containerAdd` webView - window `onDestroy` mainQuit + window `on` deleteEvent $ lift mainQuit >> return True widgetShowAll window mainGUI diff --git a/hierarchy.list b/hierarchy.list --- a/hierarchy.list +++ b/hierarchy.list @@ -340,133 +340,147 @@ WebKitWebWindowFeatures as WebWindowFeatures, webkit_web_window_features_get_type if webkit WebKitGeolocationPolicyDecision as GeolocationPolicyDecision, webkit_geolocation_policy_decision_get_type if webkit + WebKitDOMAudioTrack as AudioTrack, webkit_dom_audio_track_get_type if webkit-2.2 WebKitDOMBarProp as BarProp, webkit_dom_bar_prop_get_type if webkit-2.2 WebKitDOMBlob as Blob, webkit_dom_blob_get_type if webkit-dom WebKitDOMFile as File, webkit_dom_file_get_type if webkit-dom + WebKitDOMDOMWindowCSS as CSS, webkit_dom_dom_window_css_get_type if webkit-2.2 WebKitDOMCSSRule as CSSRule, webkit_dom_css_rule_get_type if webkit-dom WebKitDOMCSSRuleList as CSSRuleList, webkit_dom_css_rule_list_get_type if webkit-dom WebKitDOMCSSStyleDeclaration as CSSStyleDeclaration, webkit_dom_css_style_declaration_get_type if webkit-dom WebKitDOMCSSValue as CSSValue, webkit_dom_css_value_get_type if webkit-dom - WebKitDOMConsole as Console, webkit_dom_console_get_type if webkit-dom - WebKitDOMDOMApplicationCache as DOMApplicationCache, webkit_dom_dom_application_cache_get_type if webkit-dom WebKitDOMDOMImplementation as DOMImplementation, webkit_dom_dom_implementation_get_type if webkit-dom - WebKitDOMDOMMimeType as DOMMimeType, webkit_dom_dom_mime_type_get_type if webkit-dom - WebKitDOMDOMMimeTypeArray as DOMMimeTypeArray, webkit_dom_dom_mime_type_array_get_type if webkit-dom WebKitDOMDOMNamedFlowCollection as DOMNamedFlowCollection, webkit_dom_dom_named_flow_collection_get_type if webkit-2.2 - WebKitDOMDOMPlugin as DOMPlugin, webkit_dom_dom_plugin_get_type if webkit-dom - WebKitDOMDOMPluginArray as DOMPluginArray, webkit_dom_dom_plugin_array_get_type if webkit-dom - WebKitDOMDOMSecurityPolicy as DOMSecurityPolicy, webkit_dom_dom_security_policy_get_type if webkit-1.10 - WebKitDOMDOMSelection as DOMSelection, webkit_dom_dom_selection_get_type if webkit-dom WebKitDOMDOMStringList as DOMStringList, webkit_dom_dom_string_list_get_type if webkit-dom WebKitDOMDOMTokenList as DOMTokenList, webkit_dom_dom_token_list_get_type if webkit-dom WebKitDOMDOMSettableTokenList as DOMSettableTokenList, webkit_dom_dom_settable_token_list_get_type if webkit-dom - WebKitDOMDOMWindow as DOMWindow, webkit_dom_dom_window_get_type if webkit-dom - WebKitDOMDOMWindowCSS as DOMWindowCSS, webkit_dom_dom_window_css_get_type if webkit-2.2 WebKitDOMEvent as Event, webkit_dom_event_get_type if webkit-dom WebKitDOMUIEvent as UIEvent, webkit_dom_ui_event_get_type if webkit-dom - WebKitDOMMouseEvent as MouseEvent, webkit_dom_mouse_event_get_type if webkit-dom WebKitDOMKeyboardEvent as KeyboardEvent, webkit_dom_keyboard_event_get_type if webkit-2.2 + WebKitDOMMouseEvent as MouseEvent, webkit_dom_mouse_event_get_type if webkit-dom + WebKitDOMWheelEvent as WheelEvent, webkit_dom_wheel_event_get_type if webkit-2.4 WebKitDOMEventTarget as EventTarget, webkit_dom_event_target_get_type if webkit-dom + WebKitDOMDOMApplicationCache as ApplicationCache, webkit_dom_dom_application_cache_get_type if webkit-dom + WebKitDOMAudioTrackList as AudioTrackList, webkit_dom_audio_track_list_get_type if webkit-2.2 + WebKitDOMBatteryManager as BatteryManager, webkit_dom_battery_manager_get_type if webkit-2.2 + WebKitDOMMessagePort as MessagePort, webkit_dom_message_port_get_type if webkit-dom + WebKitDOMNode as Node, webkit_dom_node_get_type if webkit-dom + WebKitDOMAttr as Attr, webkit_dom_attr_get_type if webkit-dom + WebKitDOMCharacterData as CharacterData, webkit_dom_character_data_get_type if webkit-dom + WebKitDOMComment as Comment, webkit_dom_comment_get_type if webkit-dom + WebKitDOMProcessingInstruction as ProcessingInstruction, webkit_dom_processing_instruction_get_type if webkit-dom + WebKitDOMText as Text, webkit_dom_text_get_type if webkit-dom + WebKitDOMCDATASection as CDATASection, webkit_dom_cdata_section_get_type if webkit-dom + WebKitDOMDocument as Document, webkit_dom_document_get_type if webkit-dom + WebKitDOMHTMLDocument as HTMLDocument, webkit_dom_html_document_get_type if webkit-dom + WebKitDOMDocumentFragment as DocumentFragment, webkit_dom_document_fragment_get_type if webkit-dom + WebKitDOMDocumentType as DocumentType, webkit_dom_document_type_get_type if webkit-dom + WebKitDOMElement as Element, webkit_dom_element_get_type if webkit-dom + WebKitDOMHTMLElement as HTMLElement, webkit_dom_html_element_get_type if webkit-dom + WebKitDOMHTMLAnchorElement as HTMLAnchorElement, webkit_dom_html_anchor_element_get_type if webkit-dom + WebKitDOMHTMLAppletElement as HTMLAppletElement, webkit_dom_html_applet_element_get_type if webkit-dom + WebKitDOMHTMLAreaElement as HTMLAreaElement, webkit_dom_html_area_element_get_type if webkit-dom + WebKitDOMHTMLBRElement as HTMLBRElement, webkit_dom_htmlbr_element_get_type if webkit-dom + WebKitDOMHTMLBaseElement as HTMLBaseElement, webkit_dom_html_base_element_get_type if webkit-dom + WebKitDOMHTMLBaseFontElement as HTMLBaseFontElement, webkit_dom_html_base_font_element_get_type if webkit-dom + WebKitDOMHTMLBodyElement as HTMLBodyElement, webkit_dom_html_body_element_get_type if webkit-dom + WebKitDOMHTMLButtonElement as HTMLButtonElement, webkit_dom_html_button_element_get_type if webkit-dom + WebKitDOMHTMLCanvasElement as HTMLCanvasElement, webkit_dom_html_canvas_element_get_type if webkit-dom + WebKitDOMHTMLDListElement as HTMLDListElement, webkit_dom_htmld_list_element_get_type if webkit-dom + WebKitDOMHTMLDetailsElement as HTMLDetailsElement, webkit_dom_html_details_element_get_type if webkit-dom + WebKitDOMHTMLDirectoryElement as HTMLDirectoryElement, webkit_dom_html_directory_element_get_type if webkit-dom + WebKitDOMHTMLDivElement as HTMLDivElement, webkit_dom_html_div_element_get_type if webkit-dom + WebKitDOMHTMLEmbedElement as HTMLEmbedElement, webkit_dom_html_embed_element_get_type if webkit-dom + WebKitDOMHTMLFieldSetElement as HTMLFieldSetElement, webkit_dom_html_field_set_element_get_type if webkit-dom + WebKitDOMHTMLFontElement as HTMLFontElement, webkit_dom_html_font_element_get_type if webkit-dom + WebKitDOMHTMLFormElement as HTMLFormElement, webkit_dom_html_form_element_get_type if webkit-dom + WebKitDOMHTMLFrameElement as HTMLFrameElement, webkit_dom_html_frame_element_get_type if webkit-dom + WebKitDOMHTMLFrameSetElement as HTMLFrameSetElement, webkit_dom_html_frame_set_element_get_type if webkit-dom + WebKitDOMHTMLHRElement as HTMLHRElement, webkit_dom_htmlhr_element_get_type if webkit-dom + WebKitDOMHTMLHeadElement as HTMLHeadElement, webkit_dom_html_head_element_get_type if webkit-dom + WebKitDOMHTMLHeadingElement as HTMLHeadingElement, webkit_dom_html_heading_element_get_type if webkit-dom + WebKitDOMHTMLHtmlElement as HTMLHtmlElement, webkit_dom_html_html_element_get_type if webkit-dom + WebKitDOMHTMLIFrameElement as HTMLIFrameElement, webkit_dom_html_iframe_element_get_type if webkit-dom + WebKitDOMHTMLImageElement as HTMLImageElement, webkit_dom_html_image_element_get_type if webkit-dom + WebKitDOMHTMLInputElement as HTMLInputElement, webkit_dom_html_input_element_get_type if webkit-dom + WebKitDOMHTMLKeygenElement as HTMLKeygenElement, webkit_dom_html_keygen_element_get_type if webkit-dom + WebKitDOMHTMLLIElement as HTMLLIElement, webkit_dom_htmlli_element_get_type if webkit-dom + WebKitDOMHTMLLabelElement as HTMLLabelElement, webkit_dom_html_label_element_get_type if webkit-dom + WebKitDOMHTMLLegendElement as HTMLLegendElement, webkit_dom_html_legend_element_get_type if webkit-dom + WebKitDOMHTMLLinkElement as HTMLLinkElement, webkit_dom_html_link_element_get_type if webkit-dom + WebKitDOMHTMLMapElement as HTMLMapElement, webkit_dom_html_map_element_get_type if webkit-dom + WebKitDOMHTMLMarqueeElement as HTMLMarqueeElement, webkit_dom_html_marquee_element_get_type if webkit-dom + WebKitDOMHTMLMenuElement as HTMLMenuElement, webkit_dom_html_menu_element_get_type if webkit-dom + WebKitDOMHTMLMetaElement as HTMLMetaElement, webkit_dom_html_meta_element_get_type if webkit-dom + WebKitDOMHTMLModElement as HTMLModElement, webkit_dom_html_mod_element_get_type if webkit-dom + WebKitDOMHTMLOListElement as HTMLOListElement, webkit_dom_htmlo_list_element_get_type if webkit-dom + WebKitDOMHTMLObjectElement as HTMLObjectElement, webkit_dom_html_object_element_get_type if webkit-dom + WebKitDOMHTMLOptGroupElement as HTMLOptGroupElement, webkit_dom_html_opt_group_element_get_type if webkit-dom + WebKitDOMHTMLOptionElement as HTMLOptionElement, webkit_dom_html_option_element_get_type if webkit-dom + WebKitDOMHTMLParagraphElement as HTMLParagraphElement, webkit_dom_html_paragraph_element_get_type if webkit-dom + WebKitDOMHTMLParamElement as HTMLParamElement, webkit_dom_html_param_element_get_type if webkit-dom + WebKitDOMHTMLPreElement as HTMLPreElement, webkit_dom_html_pre_element_get_type if webkit-dom + WebKitDOMHTMLQuoteElement as HTMLQuoteElement, webkit_dom_html_quote_element_get_type if webkit-dom + WebKitDOMHTMLScriptElement as HTMLScriptElement, webkit_dom_html_script_element_get_type if webkit-dom + WebKitDOMHTMLSelectElement as HTMLSelectElement, webkit_dom_html_select_element_get_type if webkit-dom + WebKitDOMHTMLStyleElement as HTMLStyleElement, webkit_dom_html_style_element_get_type if webkit-dom + WebKitDOMHTMLTableCaptionElement as HTMLTableCaptionElement, webkit_dom_html_table_caption_element_get_type if webkit-dom + WebKitDOMHTMLTableCellElement as HTMLTableCellElement, webkit_dom_html_table_cell_element_get_type if webkit-dom + WebKitDOMHTMLTableColElement as HTMLTableColElement, webkit_dom_html_table_col_element_get_type if webkit-dom + WebKitDOMHTMLTableElement as HTMLTableElement, webkit_dom_html_table_element_get_type if webkit-dom + WebKitDOMHTMLTableRowElement as HTMLTableRowElement, webkit_dom_html_table_row_element_get_type if webkit-dom + WebKitDOMHTMLTableSectionElement as HTMLTableSectionElement, webkit_dom_html_table_section_element_get_type if webkit-dom + WebKitDOMHTMLTextAreaElement as HTMLTextAreaElement, webkit_dom_html_text_area_element_get_type if webkit-dom + WebKitDOMHTMLTitleElement as HTMLTitleElement, webkit_dom_html_title_element_get_type if webkit-dom + WebKitDOMHTMLUListElement as HTMLUListElement, webkit_dom_htmlu_list_element_get_type if webkit-dom + WebKitDOMEntityReference as EntityReference, webkit_dom_entity_reference_get_type if webkit-dom + WebKitDOMPerformance as Performance, webkit_dom_performance_get_type if webkit-2.2 + WebKitDOMTextTrack as TextTrack, webkit_dom_text_track_get_type if webkit-2.2 + WebKitDOMTextTrackCue as TextTrackCue, webkit_dom_text_track_cue_get_type if webkit-2.2 + WebKitDOMTextTrackList as TextTrackList, webkit_dom_text_track_list_get_type if webkit-2.2 + WebKitDOMVideoTrackList as VideoTrackList, webkit_dom_video_track_list_get_type if webkit-2.2 + WebKitDOMWebKitNamedFlow as WebKitNamedFlow, webkit_dom_webkit_named_flow_get_type if webkit-dom + WebKitDOMDOMWindow as Window, webkit_dom_dom_window_get_type if webkit-dom WebKitDOMFileList as FileList, webkit_dom_file_list_get_type if webkit-dom WebKitDOMGeolocation as Geolocation, webkit_dom_geolocation_get_type if webkit-dom WebKitDOMHTMLCollection as HTMLCollection, webkit_dom_html_collection_get_type if webkit-dom WebKitDOMHTMLOptionsCollection as HTMLOptionsCollection, webkit_dom_html_options_collection_get_type if webkit-dom + WebKitDOMHTMLMediaElement as HTMLMediaElement, webkit_dom_html_media_element_get_type if webkit-dom + WebKitDOMHTMLAudioElement as HTMLAudioElement, webkit_dom_html_audio_element_get_type if webkit-dom + WebKitDOMHTMLVideoElement as HTMLVideoElement, webkit_dom_html_video_element_get_type if webkit-dom WebKitDOMHistory as History, webkit_dom_history_get_type if webkit-dom WebKitDOMLocation as Location, webkit_dom_location_get_type if webkit-dom WebKitDOMMediaError as MediaError, webkit_dom_media_error_get_type if webkit-dom WebKitDOMMediaList as MediaList, webkit_dom_media_list_get_type if webkit-dom WebKitDOMMediaQueryList as MediaQueryList, webkit_dom_media_query_list_get_type if webkit-dom - WebKitDOMMessagePort as MessagePort, webkit_dom_message_port_get_type if webkit-dom + WebKitDOMDOMMimeType as MimeType, webkit_dom_dom_mime_type_get_type if webkit-dom + WebKitDOMDOMMimeTypeArray as MimeTypeArray, webkit_dom_dom_mime_type_array_get_type if webkit-dom WebKitDOMNamedNodeMap as NamedNodeMap, webkit_dom_named_node_map_get_type if webkit-dom WebKitDOMNavigator as Navigator, webkit_dom_navigator_get_type if webkit-dom - WebKitDOMNode as Node, webkit_dom_node_get_type if webkit-dom - WebKitDOMAttr as DOMAttr, webkit_dom_attr_get_type if webkit-dom - WebKitDOMCharacterData as CharacterData, webkit_dom_character_data_get_type if webkit-dom - WebKitDOMComment as Comment, webkit_dom_comment_get_type if webkit-dom - WebKitDOMText as Text, webkit_dom_text_get_type if webkit-dom - WebKitDOMCDATASection as CDATASection, webkit_dom_cdata_section_get_type if webkit-dom - WebKitDOMDocument as Document, webkit_dom_document_get_type if webkit-dom - WebKitDOMHTMLDocument as HTMLDocument, webkit_dom_html_document_get_type if webkit-dom - WebKitDOMDocumentFragment as DocumentFragment, webkit_dom_document_fragment_get_type if webkit-dom - WebKitDOMDocumentType as DocumentType, webkit_dom_document_type_get_type if webkit-dom - WebKitDOMElement as Element, webkit_dom_element_get_type if webkit-dom - WebKitDOMHTMLElement as HTMLElement, webkit_dom_html_element_get_type if webkit-dom - WebKitDOMHTMLAnchorElement as HTMLAnchorElement, webkit_dom_html_anchor_element_get_type if webkit-dom - WebKitDOMHTMLAppletElement as HTMLAppletElement, webkit_dom_html_applet_element_get_type if webkit-dom - WebKitDOMHTMLAreaElement as HTMLAreaElement, webkit_dom_html_area_element_get_type if webkit-dom - WebKitDOMHTMLBRElement as HTMLBRElement, webkit_dom_htmlbr_element_get_type if webkit-dom - WebKitDOMHTMLBaseElement as HTMLBaseElement, webkit_dom_html_base_element_get_type if webkit-dom - WebKitDOMHTMLBaseFontElement as HTMLBaseFontElement, webkit_dom_html_base_font_element_get_type if webkit-dom - WebKitDOMHTMLBodyElement as HTMLBodyElement, webkit_dom_html_body_element_get_type if webkit-dom - WebKitDOMHTMLButtonElement as HTMLButtonElement, webkit_dom_html_button_element_get_type if webkit-dom - WebKitDOMHTMLCanvasElement as HTMLCanvasElement, webkit_dom_html_canvas_element_get_type if webkit-dom - WebKitDOMHTMLDListElement as HTMLDListElement, webkit_dom_htmld_list_element_get_type if webkit-dom - WebKitDOMHTMLDetailsElement as HTMLDetailsElement, webkit_dom_html_details_element_get_type if webkit-dom - WebKitDOMHTMLDirectoryElement as HTMLDirectoryElement, webkit_dom_html_directory_element_get_type if webkit-dom - WebKitDOMHTMLDivElement as HTMLDivElement, webkit_dom_html_div_element_get_type if webkit-dom - WebKitDOMHTMLEmbedElement as HTMLEmbedElement, webkit_dom_html_embed_element_get_type if webkit-dom - WebKitDOMHTMLFieldSetElement as HTMLFieldSetElement, webkit_dom_html_field_set_element_get_type if webkit-dom - WebKitDOMHTMLFontElement as HTMLFontElement, webkit_dom_html_font_element_get_type if webkit-dom - WebKitDOMHTMLFormElement as HTMLFormElement, webkit_dom_html_form_element_get_type if webkit-dom - WebKitDOMHTMLFrameElement as HTMLFrameElement, webkit_dom_html_frame_element_get_type if webkit-dom - WebKitDOMHTMLFrameSetElement as HTMLFrameSetElement, webkit_dom_html_frame_set_element_get_type if webkit-dom - WebKitDOMHTMLHRElement as HTMLHRElement, webkit_dom_htmlhr_element_get_type if webkit-dom - WebKitDOMHTMLHeadElement as HTMLHeadElement, webkit_dom_html_head_element_get_type if webkit-dom - WebKitDOMHTMLHeadingElement as HTMLHeadingElement, webkit_dom_html_heading_element_get_type if webkit-dom - WebKitDOMHTMLHtmlElement as HTMLHtmlElement, webkit_dom_html_html_element_get_type if webkit-dom - WebKitDOMHTMLIFrameElement as HTMLIFrameElement, webkit_dom_html_iframe_element_get_type if webkit-dom - WebKitDOMHTMLImageElement as HTMLImageElement, webkit_dom_html_image_element_get_type if webkit-dom - WebKitDOMHTMLInputElement as HTMLInputElement, webkit_dom_html_input_element_get_type if webkit-dom - WebKitDOMHTMLKeygenElement as HTMLKeygenElement, webkit_dom_html_keygen_element_get_type if webkit-dom - WebKitDOMHTMLLIElement as HTMLLIElement, webkit_dom_htmlli_element_get_type if webkit-dom - WebKitDOMHTMLLabelElement as HTMLLabelElement, webkit_dom_html_label_element_get_type if webkit-dom - WebKitDOMHTMLLegendElement as HTMLLegendElement, webkit_dom_html_legend_element_get_type if webkit-dom - WebKitDOMHTMLLinkElement as HTMLLinkElement, webkit_dom_html_link_element_get_type if webkit-dom - WebKitDOMHTMLMapElement as HTMLMapElement, webkit_dom_html_map_element_get_type if webkit-dom - WebKitDOMHTMLMarqueeElement as HTMLMarqueeElement, webkit_dom_html_marquee_element_get_type if webkit-dom - WebKitDOMHTMLMediaElement as HTMLMediaElement, webkit_dom_html_media_element_get_type if webkit-dom - WebKitDOMHTMLAudioElement as HTMLAudioElement, webkit_dom_html_audio_element_get_type if webkit-dom - WebKitDOMHTMLVideoElement as HTMLVideoElement, webkit_dom_html_video_element_get_type if webkit-dom - WebKitDOMHTMLMenuElement as HTMLMenuElement, webkit_dom_html_menu_element_get_type if webkit-dom - WebKitDOMHTMLMetaElement as HTMLMetaElement, webkit_dom_html_meta_element_get_type if webkit-dom - WebKitDOMHTMLModElement as HTMLModElement, webkit_dom_html_mod_element_get_type if webkit-dom - WebKitDOMHTMLOListElement as HTMLOListElement, webkit_dom_htmlo_list_element_get_type if webkit-dom - WebKitDOMHTMLObjectElement as HTMLObjectElement, webkit_dom_html_object_element_get_type if webkit-dom - WebKitDOMHTMLOptGroupElement as HTMLOptGroupElement, webkit_dom_html_opt_group_element_get_type if webkit-dom - WebKitDOMHTMLOptionElement as HTMLOptionElement, webkit_dom_html_option_element_get_type if webkit-dom - WebKitDOMHTMLParagraphElement as HTMLParagraphElement, webkit_dom_html_paragraph_element_get_type if webkit-dom - WebKitDOMHTMLParamElement as HTMLParamElement, webkit_dom_html_param_element_get_type if webkit-dom - WebKitDOMHTMLPreElement as HTMLPreElement, webkit_dom_html_pre_element_get_type if webkit-dom - WebKitDOMHTMLQuoteElement as HTMLQuoteElement, webkit_dom_html_quote_element_get_type if webkit-dom - WebKitDOMHTMLScriptElement as HTMLScriptElement, webkit_dom_html_script_element_get_type if webkit-dom - WebKitDOMHTMLSelectElement as HTMLSelectElement, webkit_dom_html_select_element_get_type if webkit-dom - WebKitDOMHTMLStyleElement as HTMLStyleElement, webkit_dom_html_style_element_get_type if webkit-dom - WebKitDOMHTMLTableCaptionElement as HTMLTableCaptionElement, webkit_dom_html_table_caption_element_get_type if webkit-dom - WebKitDOMHTMLTableCellElement as HTMLTableCellElement, webkit_dom_html_table_cell_element_get_type if webkit-dom - WebKitDOMHTMLTableColElement as HTMLTableColElement, webkit_dom_html_table_col_element_get_type if webkit-dom - WebKitDOMHTMLTableElement as HTMLTableElement, webkit_dom_html_table_element_get_type if webkit-dom - WebKitDOMHTMLTableRowElement as HTMLTableRowElement, webkit_dom_html_table_row_element_get_type if webkit-dom - WebKitDOMHTMLTableSectionElement as HTMLTableSectionElement, webkit_dom_html_table_section_element_get_type if webkit-dom - WebKitDOMHTMLTextAreaElement as HTMLTextAreaElement, webkit_dom_html_text_area_element_get_type if webkit-dom - WebKitDOMHTMLTitleElement as HTMLTitleElement, webkit_dom_html_title_element_get_type if webkit-dom - WebKitDOMHTMLUListElement as HTMLUListElement, webkit_dom_htmlu_list_element_get_type if webkit-dom - WebKitDOMEntityReference as EntityReference, webkit_dom_entity_reference_get_type if webkit-dom - WebKitDOMProcessingInstruction as ProcessingInstruction, webkit_dom_processing_instruction_get_type if webkit-dom WebKitDOMNodeFilter as NodeFilter, webkit_dom_node_filter_get_type if webkit-dom WebKitDOMNodeIterator as NodeIterator, webkit_dom_node_iterator_get_type if webkit-dom WebKitDOMNodeList as NodeList, webkit_dom_node_list_get_type if webkit-dom - WebKitDOMRange as DOMRange, webkit_dom_range_get_type if webkit-dom - WebKitDOMScreen as DOMScreen, webkit_dom_screen_get_type if webkit-dom + WebKitDOMPerformanceNavigation as PerformanceNavigation, webkit_dom_performance_navigation_get_type if webkit-2.2 + WebKitDOMPerformanceTiming as PerformanceTiming, webkit_dom_performance_timing_get_type if webkit-2.2 + WebKitDOMDOMPlugin as Plugin, webkit_dom_dom_plugin_get_type if webkit-dom + WebKitDOMDOMPluginArray as PluginArray, webkit_dom_dom_plugin_array_get_type if webkit-dom + WebKitDOMRange as Range, webkit_dom_range_get_type if webkit-dom + WebKitDOMScreen as Screen, webkit_dom_screen_get_type if webkit-dom + WebKitDOMDOMSecurityPolicy as SecurityPolicy, webkit_dom_dom_security_policy_get_type if webkit-1.10 + WebKitDOMDOMSelection as Selection, webkit_dom_dom_selection_get_type if webkit-dom WebKitDOMStorage as Storage, webkit_dom_storage_get_type if webkit-dom WebKitDOMStorageInfo as StorageInfo, webkit_dom_storage_info_get_type if webkit-1.10 + WebKitDOMStorageQuota as StorageQuota, webkit_dom_storage_quota_get_type if webkit-2.2 WebKitDOMStyleMedia as StyleMedia, webkit_dom_style_media_get_type if webkit-dom WebKitDOMStyleSheet as StyleSheet, webkit_dom_style_sheet_get_type if webkit-dom WebKitDOMCSSStyleSheet as CSSStyleSheet, webkit_dom_css_style_sheet_get_type if webkit-dom WebKitDOMStyleSheetList as StyleSheetList, webkit_dom_style_sheet_list_get_type if webkit-dom + WebKitDOMTextTrackCueList as TextTrackCueList, webkit_dom_text_track_cue_list_get_type if webkit-2.2 WebKitDOMTimeRanges as TimeRanges, webkit_dom_time_ranges_get_type if webkit-dom + WebKitDOMTouch as Touch, webkit_dom_touch_get_type if webkit-2.4 WebKitDOMTreeWalker as TreeWalker, webkit_dom_tree_walker_get_type if webkit-dom WebKitDOMValidityState as ValidityState, webkit_dom_validity_state_get_type if webkit-dom - WebKitDOMWebKitNamedFlow as WebKitNamedFlow, webkit_dom_webkit_named_flow_get_type if webkit-dom + WebKitDOMVideoTrack as VideoTrack, webkit_dom_video_track_get_type if webkit-2.2 WebKitDOMWebKitPoint as WebKitPoint, webkit_dom_webkit_point_get_type if webkit-dom WebKitDOMXPathExpression as XPathExpression, webkit_dom_xpath_expression_get_type if webkit-dom WebKitDOMXPathNSResolver as XPathNSResolver, webkit_dom_xpath_ns_resolver_get_type if webkit-dom diff --git a/hswebkit.h b/hswebkit.h --- a/hswebkit.h +++ b/hswebkit.h @@ -17,6 +17,10 @@ * Boston, MA 02110-1301, USA. */ +#ifdef __BLOCKS__ +#undef __BLOCKS__ +#endif + #ifndef HS_WEBKIT_H #define HS_WEBKIT_H /* to avoid stdbool.h error in JavaScriptCore/JSBase.h*/ @@ -31,3 +35,86 @@ #endif #include "events.h" + +#undef Bool +#undef True +#undef False +#undef true +#undef false +#undef Button1 +#undef Button2 +#undef Button3 +#undef Button4 +#undef Button5 +#undef Button1Mask +#undef Button2Mask +#undef Button3Mask +#undef Button4Mask +#undef Button5Mask + +#undef ShiftMask +#undef LockMask +#undef ControlMask +#undef Mod1Mask +#undef Mod2Mask +#undef Mod3Mask +#undef Mod4Mask +#undef Mod5Mask + +#undef None +#undef ParentRelative +#undef CopyFromParent +#undef PointerWindow +#undef InputFocus +#undef PointerRoot +#undef AnyPropertyType +#undef AnyKey +#undef AnyButton +#undef AllTemporary +#undef CurrentTime +#undef NoSymbol + +#undef NoEventMask +#undef KeyPressMask +#undef KeyReleaseMask +#undef ButtonPressMask +#undef ButtonReleaseMask +#undef EnterWindowMask +#undef LeaveWindowMask +#undef PointerMotionMask +#undef PointerMotionHintMask +#undef Button1MotionMask +#undef Button2MotionMask +#undef Button3MotionMask +#undef Button4MotionMask +#undef Button5MotionMask +#undef ButtonMotionMask +#undef KeymapStateMask +#undef ExposureMask +#undef VisibilityChangeMask +#undef StructureNotifyMask +#undef ResizeRedirectMask +#undef SubstructureNotifyMask +#undef SubstructureRedirectMask +#undef FocusChangeMask +#undef PropertyChangeMask +#undef ColormapChangeMask +#undef OwnerGrabButtonMask +#undef Status +#undef Expose +#undef Below +#undef GrabSuccess +#undef GrabAlreadyGrabbed +#undef GrabInvalidTime +#undef GrabNotViewable +#undef GrabFrozen +#undef OwnerChangeNewOwner +#undef OwnerChangeDestroy +#undef OwnerChangeClose +#undef NULL + +#if !WEBKIT_CHECK_VERSION(2,4,0) +#define webkit_dom_event_target_add_event_listener_with_closure webkit_dom_event_target_add_event_listener_closure +#define webkit_dom_event_target_remove_event_listener_with_closure webkit_dom_event_target_remove_event_listener_closure +#endif + diff --git a/marshal.list b/marshal.list --- a/marshal.list +++ b/marshal.list @@ -14,8 +14,8 @@ # FLAGS for flag enumeration types (guint) # FLOAT for single-precision float types (gfloat) # DOUBLE for double-precision float types (gdouble) -# STRING for string types (gchar*) -# MSTRING for string types (gchar*) that could be NUL +# GLIBSTRING for string types (gchar*) +# MGLIBSTRING for string types (gchar*) that could be NUL # BOXED for boxed (anonymous but reference counted) types (GBoxed*) # POINTER for anonymous pointer types (gpointer) # NONE deprecated alias for VOID @@ -45,24 +45,24 @@ VOID:POINTER,POINTER BOOLEAN:TOBJECT -BOOLEAN:TOBJECT,STRING,BOXED +BOOLEAN:TOBJECT,GLIBSTRING,BOXED POINTER:TOBJECT -BOOLEAN:INT,INT,STRING -BOOLEAN:STRING,STRING,INT,STRING -BOOLEAN:TOBJECT,STRING -BOOLEAN:TOBJECT,STRING,STRING +BOOLEAN:INT,INT,GLIBSTRING +BOOLEAN:GLIBSTRING,GLIBSTRING,INT,GLIBSTRING +BOOLEAN:TOBJECT,GLIBSTRING +BOOLEAN:TOBJECT,GLIBSTRING,GLIBSTRING BOOLEAN:TOBJECT,TOBJECT BOOLEAN:TOBJECT,TOBJECT,TOBJECT,TOBJECT -BOOLEAN:TOBJECT,TOBJECT,STRING,TOBJECT +BOOLEAN:TOBJECT,TOBJECT,GLIBSTRING,TOBJECT NONE:TOBJECT,TOBJECT,TOBJECT,TOBJECT NONE:TOBJECT,TOBJECT,MTOBJECT,MTOBJECT BOOLEAN:ENUM,INT BOOLEAN:NONE NONE:NONE -NONE:MSTRING,MSTRING -NONE:TOBJECT,STRING +NONE:MGLIBSTRING,MGLIBSTRING +NONE:TOBJECT,GLIBSTRING NONE:TOBJECT,TOBJECT -NONE:STRING,STRING +NONE:GLIBSTRING,GLIBSTRING NONE:TOBJECT NONE:INT -NONE:STRING +NONE:GLIBSTRING diff --git a/webkit.cabal b/webkit.cabal --- a/webkit.cabal +++ b/webkit.cabal @@ -1,15 +1,15 @@ Name: webkit -Version: 0.12.6.1 +Version: 0.14.2.1 License: LGPL-2.1 License-file: COPYING Copyright: (c) 2001-2013 The Gtk2Hs Team Author: Cjacker Huang, Andy Stewart, Axel Simon Maintainer: gtk2hs-users@lists.sourceforge.net Build-Type: Custom -Cabal-Version: >= 1.8 +Cabal-Version: >= 1.24 Stability: provisional homepage: http://projects.haskell.org/gtk2hs/ -bug-reports: http://hackage.haskell.org/trac/gtk2hs/ +bug-reports: https://github.com/gtk2hs/webkit/issues Synopsis: Binding to the Webkit library. Description: WebKit is a web content engine, derived from KHTML and KJS from KDE, and used primarily in Apple's Safari browser. It is made to be embedded in @@ -21,7 +21,6 @@ Category: Graphics Tested-With: GHC == 6.10.4, GHC == 6.12.3, GHC == 7.0.4, GHC == 7.2.1, GHC == 7.6.3 Extra-Source-Files: hswebkit.h - SetupWrapper.hs SetupMain.hs Gtk2HsSetup.hs marshal.list hierarchy.list cbits/events.h @@ -34,7 +33,7 @@ x-Types-File: Graphics/UI/Gtk/WebKit/Types.chs x-Types-Tag: webkit webkit-dom x-Types-ModName: Graphics.UI.Gtk.WebKit.Types -x-Types-Forward: *Graphics.UI.GtkInternals +x-Types-Forward: Graphics.UI.Gtk.WebKit.GtkInternals x-Types-Destructor: objectUnrefFromMainloop x-Types-Hierarchy: hierarchy.list @@ -42,14 +41,23 @@ type: git location: https://github.com/gtk2hs/webkit +custom-setup + setup-depends: base >= 4.6, + Cabal >= 1.24 && < 1.25, + gtk2hs-buildtools >= 0.13.1.0 && < 0.14 + Library build-depends: base >= 4 && < 5, - glib >= 0.12.1 && < 0.13, - pango >= 0.12 && < 0.13, - cairo >= 0.12 && < 0.13, - mtl + bytestring >= 0.9.2 && < 0.11, + glib >= 0.13.1.0 && < 0.14, + pango >= 0.13.0.0 && < 0.14, + cairo >= 0.13.0.0 && < 0.14, + gtk >= 0.13.0.0 && < 0.15, + text >= 1.0.0.0 && < 1.3, + mtl, + transformers - build-tools: gtk2hsC2hs >= 0.13.8, + build-tools: gtk2hsC2hs >= 0.13.11, gtk2hsHookGenerator, gtk2hsTypeGen c-sources: Graphics/UI/Gtk/WebKit/DOM/hsevents.c include-dirs: cbits @@ -58,6 +66,7 @@ Graphics.UI.Gtk.WebKit.CacheModel Graphics.UI.Gtk.WebKit.Download Graphics.UI.Gtk.WebKit.GeolocationPolicyDecision + Graphics.UI.Gtk.WebKit.GtkInternals Graphics.UI.Gtk.WebKit.HitTestResult Graphics.UI.Gtk.WebKit.NetworkRequest Graphics.UI.Gtk.WebKit.NetworkResponse @@ -76,12 +85,15 @@ Graphics.UI.Gtk.WebKit.WebSettings Graphics.UI.Gtk.WebKit.WebView Graphics.UI.Gtk.WebKit.WebWindowFeatures + Graphics.UI.Gtk.WebKit.DOM.ApplicationCache Graphics.UI.Gtk.WebKit.DOM.Attr + Graphics.UI.Gtk.WebKit.DOM.AudioTrack + Graphics.UI.Gtk.WebKit.DOM.AudioTrackList Graphics.UI.Gtk.WebKit.DOM.BarProp + Graphics.UI.Gtk.WebKit.DOM.BatteryManager Graphics.UI.Gtk.WebKit.DOM.Blob Graphics.UI.Gtk.WebKit.DOM.CharacterData - Graphics.UI.Gtk.WebKit.DOM.Console - Graphics.UI.Gtk.WebKit.DOM.Css + Graphics.UI.Gtk.WebKit.DOM.CSS Graphics.UI.Gtk.WebKit.DOM.CSSRule Graphics.UI.Gtk.WebKit.DOM.CSSRuleList Graphics.UI.Gtk.WebKit.DOM.CSSStyleDeclaration @@ -89,23 +101,15 @@ Graphics.UI.Gtk.WebKit.DOM.CSSValue Graphics.UI.Gtk.WebKit.DOM.Document Graphics.UI.Gtk.WebKit.DOM.DocumentType - Graphics.UI.Gtk.WebKit.DOM.DOMApplicationCache Graphics.UI.Gtk.WebKit.DOM.DOMImplementation - Graphics.UI.Gtk.WebKit.DOM.DOMMimeType - Graphics.UI.Gtk.WebKit.DOM.DOMMimeTypeArray Graphics.UI.Gtk.WebKit.DOM.DOMNamedFlowCollection - Graphics.UI.Gtk.WebKit.DOM.DOMPlugin - Graphics.UI.Gtk.WebKit.DOM.DOMPluginArray - Graphics.UI.Gtk.WebKit.DOM.DOMSelection Graphics.UI.Gtk.WebKit.DOM.DOMSettableTokenList Graphics.UI.Gtk.WebKit.DOM.DOMTokenList - Graphics.UI.Gtk.WebKit.DOM.DOMWindow - Graphics.UI.Gtk.WebKit.DOM.DOMWindowCSS Graphics.UI.Gtk.WebKit.DOM.Element + Graphics.UI.Gtk.WebKit.DOM.Enums Graphics.UI.Gtk.WebKit.DOM.Event Graphics.UI.Gtk.WebKit.DOM.EventM - Graphics.UI.Gtk.WebKit.DOM.Events --- Graphics.UI.Gtk.WebKit.DOM.EventTarget + Graphics.UI.Gtk.WebKit.DOM.EventTarget Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures Graphics.UI.Gtk.WebKit.DOM.File Graphics.UI.Gtk.WebKit.DOM.FileList @@ -169,6 +173,8 @@ Graphics.UI.Gtk.WebKit.DOM.Location Graphics.UI.Gtk.WebKit.DOM.MediaList Graphics.UI.Gtk.WebKit.DOM.MediaQueryList + Graphics.UI.Gtk.WebKit.DOM.MimeType + Graphics.UI.Gtk.WebKit.DOM.MimeTypeArray Graphics.UI.Gtk.WebKit.DOM.MouseEvent Graphics.UI.Gtk.WebKit.DOM.NamedNodeMap Graphics.UI.Gtk.WebKit.DOM.Navigator @@ -176,26 +182,38 @@ Graphics.UI.Gtk.WebKit.DOM.NodeFilter Graphics.UI.Gtk.WebKit.DOM.NodeIterator Graphics.UI.Gtk.WebKit.DOM.NodeList + Graphics.UI.Gtk.WebKit.DOM.Performance + Graphics.UI.Gtk.WebKit.DOM.PerformanceNavigation + Graphics.UI.Gtk.WebKit.DOM.PerformanceTiming + Graphics.UI.Gtk.WebKit.DOM.Plugin + Graphics.UI.Gtk.WebKit.DOM.PluginArray Graphics.UI.Gtk.WebKit.DOM.ProcessingInstruction Graphics.UI.Gtk.WebKit.DOM.Range - Graphics.UI.Gtk.WebKit.DOM.Ranges Graphics.UI.Gtk.WebKit.DOM.Screen + Graphics.UI.Gtk.WebKit.DOM.SecurityPolicy + Graphics.UI.Gtk.WebKit.DOM.Selection Graphics.UI.Gtk.WebKit.DOM.StyleMedia Graphics.UI.Gtk.WebKit.DOM.StyleSheet Graphics.UI.Gtk.WebKit.DOM.StyleSheetList - Graphics.UI.Gtk.WebKit.DOM.Stylesheets Graphics.UI.Gtk.WebKit.DOM.Storage Graphics.UI.Gtk.WebKit.DOM.Text - Graphics.UI.Gtk.WebKit.DOM.Traversal + Graphics.UI.Gtk.WebKit.DOM.TextTrack + Graphics.UI.Gtk.WebKit.DOM.TextTrackCue + Graphics.UI.Gtk.WebKit.DOM.TextTrackCueList + Graphics.UI.Gtk.WebKit.DOM.TextTrackList Graphics.UI.Gtk.WebKit.DOM.TreeWalker + Graphics.UI.Gtk.WebKit.DOM.Touch Graphics.UI.Gtk.WebKit.DOM.UIEvent Graphics.UI.Gtk.WebKit.DOM.ValidityState + Graphics.UI.Gtk.WebKit.DOM.VideoTrack + Graphics.UI.Gtk.WebKit.DOM.VideoTrackList Graphics.UI.Gtk.WebKit.DOM.WebKitNamedFlow Graphics.UI.Gtk.WebKit.DOM.WebKitPoint + Graphics.UI.Gtk.WebKit.DOM.WheelEvent + Graphics.UI.Gtk.WebKit.DOM.Window Graphics.UI.Gtk.WebKit.DOM.XPathExpression Graphics.UI.Gtk.WebKit.DOM.XPathNSResolver Graphics.UI.Gtk.WebKit.DOM.XPathResult - Graphics.UI.Gtk.WebKit.DOM.DOMSecurityPolicy Graphics.UI.Gtk.WebKit.DOM.DOMStringList Graphics.UI.Gtk.WebKit.DOM.Geolocation Graphics.UI.Gtk.WebKit.DOM.HTMLCanvasElement @@ -215,8 +233,10 @@ Graphics.UI.Gtk.WebKit.Internal Graphics.UI.Gtk.WebKit.Signals - extensions: ForeignFunctionInterface + default-language: Haskell98 + default-extensions: ForeignFunctionInterface, PatternSynonyms, DeriveDataTypeable include-dirs: . + cpp-options: -DDISABLE_DEPRECATED -U__BLOCKS__ -D__attribute__(A)= -D_Nullable= -D_Nonnull= x-Signals-File: Graphics/UI/Gtk/WebKit/Signals.chs x-Signals-Modname: Graphics.UI.Gtk.WebKit.Signals @@ -225,5 +245,4 @@ hs-source-dirs: . pkgconfig-depends: webkit-1.0 >= 1.8 - build-depends: gtk >=0.12.5.4 && <0.13 x-c2hs-Header: hswebkit.h