packages feed

webkit 0.13.1.3 → 0.14.1.0

raw patch · 169 files changed

+21029/−14759 lines, 169 filesdep +transformersdep ~gtk

Dependencies added: transformers

Dependency ranges changed: gtk

Files

+ Graphics/UI/Gtk/WebKit/DOM/ApplicationCache.chs view
@@ -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"
Graphics/UI/Gtk/WebKit/DOM/Attr.chs view
@@ -1,49 +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, GlibString string) => 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, GlibString string) => 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, GlibString string) => 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)))
+ Graphics/UI/Gtk/WebKit/DOM/AudioTrack.chs view
@@ -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
+ Graphics/UI/Gtk/WebKit/DOM/AudioTrackList.chs view
@@ -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
Graphics/UI/Gtk/WebKit/DOM/BarProp.chs view
@@ -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
+ Graphics/UI/Gtk/WebKit/DOM/BatteryManager.chs view
@@ -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
Graphics/UI/Gtk/WebKit/DOM/Blob.chs view
@@ -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)))
+ Graphics/UI/Gtk/WebKit/DOM/CSS.chs view
@@ -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
Graphics/UI/Gtk/WebKit/DOM/CSSRule.chs view
@@ -1,52 +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, GlibString string) => 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, GlibString string) => 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)))
Graphics/UI/Gtk/WebKit/DOM/CSSRuleList.chs view
@@ -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)))
Graphics/UI/Gtk/WebKit/DOM/CSSStyleDeclaration.chs view
@@ -1,146 +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, GlibString string) =>-                                      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, GlibString string) =>-                                    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, GlibString string) =>-                                         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, GlibString string) =>-                                 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, GlibString string) =>-                          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, GlibString string) =>-                                          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, GlibString string) =>-                                        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, GlibString string) =>-                                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, GlibString string) =>-                                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)))
Graphics/UI/Gtk/WebKit/DOM/CSSStyleSheet.chs view
@@ -1,87 +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, GlibString string) =>-                          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, GlibString string) =>-                       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)))
Graphics/UI/Gtk/WebKit/DOM/CSSValue.chs view
@@ -1,39 +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, GlibString string) => 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, GlibString string) => 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)))
Graphics/UI/Gtk/WebKit/DOM/CharacterData.chs view
@@ -1,109 +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, GlibString string) =>-                             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, GlibString string) =>-                          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, GlibString string) =>-                          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, GlibString string) =>-                           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, GlibString string) =>-                       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, GlibString string) => 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)))
− Graphics/UI/Gtk/WebKit/DOM/Console.chs 
@@ -1,21 +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, GlibString string) => 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)
− Graphics/UI/Gtk/WebKit/DOM/Css.chs 
@@ -1,7 +0,0 @@-module Graphics.UI.Gtk.WebKit.DOM.Css (CSSRule, CSSRuleClass) where- -data CSSRule = CSSRule- -class CSSRuleClass a- -instance CSSRuleClass CSSRule
− Graphics/UI/Gtk/WebKit/DOM/DOMApplicationCache.chs 
@@ -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")
Graphics/UI/Gtk/WebKit/DOM/DOMImplementation.chs view
@@ -1,97 +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, GlibString string) =>-                              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, GlibString string) =>-                                      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,-                                 GlibString string) =>-                                  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, GlibString string) =>-                                       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, GlibString string) =>-                                      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))
− Graphics/UI/Gtk/WebKit/DOM/DOMMimeType.chs 
@@ -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, GlibString string) => self -> IO string-domMimeTypeGetSuffixes self-  = ({# call webkit_dom_dom_mime_type_get_suffixes #}-       (toDOMMimeType self))-      >>=-      readUTFString- -domMimeTypeGetDescription ::-                          (DOMMimeTypeClass self, GlibString string) => 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))
− Graphics/UI/Gtk/WebKit/DOM/DOMMimeTypeArray.chs 
@@ -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, GlibString string) =>-                            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))
Graphics/UI/Gtk/WebKit/DOM/DOMNamedFlowCollection.chs view
@@ -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, GlibString string) =>-                                  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
− Graphics/UI/Gtk/WebKit/DOM/DOMPlugin.chs 
@@ -1,57 +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, GlibString string) =>-                     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, GlibString string) => self -> IO string-domPluginGetName self-  = ({# call webkit_dom_dom_plugin_get_name #} (toDOMPlugin self))-      >>=-      readUTFString- -domPluginGetFilename ::-                     (DOMPluginClass self, GlibString string) => self -> IO string-domPluginGetFilename self-  = ({# call webkit_dom_dom_plugin_get_filename #}-       (toDOMPlugin self))-      >>=-      readUTFString- -domPluginGetDescription ::-                        (DOMPluginClass self, GlibString string) => 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))
− Graphics/UI/Gtk/WebKit/DOM/DOMPluginArray.chs 
@@ -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, GlibString string) =>-                          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))
− Graphics/UI/Gtk/WebKit/DOM/DOMSecurityPolicy.chs 
@@ -1,181 +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, GlibString string) =>-                                      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, GlibString string) =>-                                  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, GlibString string) =>-                                    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, GlibString string) =>-                                   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, GlibString string) =>-                                   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, GlibString string) =>-                                   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, GlibString string) =>-                                    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, GlibString string) =>-                                    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, GlibString string) =>-                                    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, GlibString string) =>-                                   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
− Graphics/UI/Gtk/WebKit/DOM/DOMSelection.chs 
@@ -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, GlibString string) =>-                     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))
Graphics/UI/Gtk/WebKit/DOM/DOMSettableTokenList.chs view
@@ -1,31 +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, GlibString string) =>-                               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, GlibString string) =>-                               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)
Graphics/UI/Gtk/WebKit/DOM/DOMStringList.chs view
@@ -1,39 +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, GlibString string) =>-                    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, GlibString string) =>-                        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)))
Graphics/UI/Gtk/WebKit/DOM/DOMTokenList.chs view
@@ -1,83 +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, GlibString string) =>-                   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, GlibString string) =>-                       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, GlibString string) => 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, GlibString string) => 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, GlibString string) =>-                     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, GlibString string) => 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)))
− Graphics/UI/Gtk/WebKit/DOM/DOMWindow.chs 
@@ -1,920 +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, GlibString string) => self -> string -> IO ()-domWindowAlert self message-  = withUTFString message $-      \ messagePtr ->-        {# call webkit_dom_dom_window_alert #} (toDOMWindow self)-          messagePtr- -domWindowConfirm ::-                 (DOMWindowClass self, GlibString string) =>-                   self -> string -> IO Bool-domWindowConfirm self message-  = toBool <$>-      (withUTFString message $-         \ messagePtr ->-           {# call webkit_dom_dom_window_confirm #} (toDOMWindow self)-             messagePtr)- -domWindowPrompt ::-                (DOMWindowClass self, GlibString string) =>-                  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, GlibString string) =>-                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, GlibString string) =>-                      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, GlibString string) =>-                            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, GlibString string) => 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, GlibString string) => 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, GlibString string) => self -> string -> IO ()-domWindowSetName self val-  = withUTFString val $-      \ valPtr ->-        {# call webkit_dom_dom_window_set_name #} (toDOMWindow self) valPtr- -domWindowGetName ::-                 (DOMWindowClass self, GlibString string) => self -> IO string-domWindowGetName self-  = ({# call webkit_dom_dom_window_get_name #} (toDOMWindow self))-      >>=-      readUTFString- -domWindowSetStatus ::-                   (DOMWindowClass self, GlibString string) => self -> string -> IO ()-domWindowSetStatus self val-  = withUTFString val $-      \ valPtr ->-        {# call webkit_dom_dom_window_set_status #} (toDOMWindow self)-          valPtr- -domWindowGetStatus ::-                   (DOMWindowClass self, GlibString string) => self -> IO string-domWindowGetStatus self-  = ({# call webkit_dom_dom_window_get_status #} (toDOMWindow self))-      >>=-      readUTFString- -domWindowSetDefaultStatus ::-                          (DOMWindowClass self, GlibString string) => self -> string -> IO ()-domWindowSetDefaultStatus self val-  = withUTFString val $-      \ valPtr ->-        {# call webkit_dom_dom_window_set_default_status #}-          (toDOMWindow self)-          valPtr- -domWindowGetDefaultStatus ::-                          (DOMWindowClass self, GlibString string) => 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
− Graphics/UI/Gtk/WebKit/DOM/DOMWindowCSS.chs 
@@ -1,28 +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, GlibString string) =>-                       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
Graphics/UI/Gtk/WebKit/DOM/Document.chs view
@@ -1,1081 +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, GlibString string) =>-                        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, GlibString string) =>-                         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, GlibString string) =>-                        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, GlibString string) =>-                             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, GlibString string) =>-                                      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, GlibString string) =>-                          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, GlibString string) =>-                                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, GlibString string) =>-                               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, GlibString string) =>-                          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, GlibString string) =>-                            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, GlibString string) =>-                                 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, GlibString string) =>-                         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, GlibString string) =>-                      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, GlibString string) =>-                           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,-                          GlibString string) =>-                           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,-                  GlibString string) =>-                   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, GlibString string) =>-                      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, GlibString string) =>-                              self -> string -> IO Bool-documentQueryCommandEnabled self command-  = toBool <$>-      (withUTFString command $-         \ commandPtr ->-           {# call webkit_dom_document_query_command_enabled #}-             (toDocument self)-             commandPtr)--documentQueryCommandIndeterm ::-                             (DocumentClass self, GlibString string) =>-                               self -> string -> IO Bool-documentQueryCommandIndeterm self command-  = toBool <$>-      (withUTFString command $-         \ commandPtr ->-           {# call webkit_dom_document_query_command_indeterm #}-             (toDocument self)-             commandPtr)--documentQueryCommandState ::-                          (DocumentClass self, GlibString string) =>-                            self -> string -> IO Bool-documentQueryCommandState self command-  = toBool <$>-      (withUTFString command $-         \ commandPtr ->-           {# call webkit_dom_document_query_command_state #}-             (toDocument self)-             commandPtr)--documentQueryCommandSupported ::-                              (DocumentClass self, GlibString string) =>-                                self -> string -> IO Bool-documentQueryCommandSupported self command-  = toBool <$>-      (withUTFString command $-         \ commandPtr ->-           {# call webkit_dom_document_query_command_supported #}-             (toDocument self)-             commandPtr)--documentQueryCommandValue ::-                          (DocumentClass self, GlibString string) =>-                            self -> string -> IO string-documentQueryCommandValue self command-  = (withUTFString command $-       \ commandPtr ->-         {# call webkit_dom_document_query_command_value #}-           (toDocument self)-           commandPtr)-      >>=-      readUTFString--documentGetElementsByName ::-                          (DocumentClass self, GlibString string) =>-                            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, GlibString string) =>-                                 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, GlibString string) =>-                        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, GlibString string) =>-                           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, GlibString string) => self -> IO string-documentGetInputEncoding self-  = ({# call webkit_dom_document_get_input_encoding #}-       (toDocument self))-      >>=-      readUTFString- -documentGetXmlEncoding ::-                       (DocumentClass self, GlibString string) => self -> IO string-documentGetXmlEncoding self-  = ({# call webkit_dom_document_get_xml_encoding #}-       (toDocument self))-      >>=-      readUTFString--documentSetXmlVersion ::-                      (DocumentClass self, GlibString string) => 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, GlibString string) => 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, GlibString string) => self -> string -> IO ()-documentSetDocumentURI self val-  = withUTFString val $-      \ valPtr ->-        {# call webkit_dom_document_set_document_uri #} (toDocument self)-          valPtr- -documentGetDocumentURI ::-                       (DocumentClass self, GlibString string) => 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, GlibString string) => self -> string -> IO ()-documentSetTitle self val-  = withUTFString val $-      \ valPtr ->-        {# call webkit_dom_document_set_title #} (toDocument self) valPtr- -documentGetTitle ::-                 (DocumentClass self, GlibString string) => self -> IO string-documentGetTitle self-  = ({# call webkit_dom_document_get_title #} (toDocument self)) >>=-      readUTFString- -documentGetReferrer ::-                    (DocumentClass self, GlibString string) => self -> IO string-documentGetReferrer self-  = ({# call webkit_dom_document_get_referrer #} (toDocument self))-      >>=-      readUTFString- -documentGetDomain ::-                  (DocumentClass self, GlibString string) => self -> IO string-documentGetDomain self-  = ({# call webkit_dom_document_get_domain #} (toDocument self)) >>=-      readUTFString--documentSetCookie ::-                  (DocumentClass self, GlibString string) => self -> string -> IO ()-documentSetCookie self val-  = propagateGError $-      \ errorPtr_ ->-        withUTFString val $-          \ valPtr ->-            {# call webkit_dom_document_set_cookie #} (toDocument self) valPtr-          errorPtr_- -documentGetCookie ::-                  (DocumentClass self, GlibString string) => 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, GlibString string) => self -> IO string-documentGetLastModified self-  = ({# call webkit_dom_document_get_last_modified #}-       (toDocument self))-      >>=-      readUTFString--documentSetCharset ::-                   (DocumentClass self, GlibString string) => self -> string -> IO ()-documentSetCharset self val-  = withUTFString val $-      \ valPtr ->-        {# call webkit_dom_document_set_charset #} (toDocument self) valPtr- -documentGetCharset ::-                   (DocumentClass self, GlibString string) => self -> IO string-documentGetCharset self-  = ({# call webkit_dom_document_get_charset #} (toDocument self))-      >>=-      readUTFString--documentGetDefaultCharset ::-                          (DocumentClass self, GlibString string) => self -> IO string-documentGetDefaultCharset self-  = ({# call webkit_dom_document_get_default_charset #}-       (toDocument self))-      >>=-      readUTFString- -documentGetReadyState ::-                      (DocumentClass self, GlibString string) => self -> IO string-documentGetReadyState self-  = ({# call webkit_dom_document_get_ready_state #}-       (toDocument self))-      >>=-      readUTFString--documentGetCharacterSet ::-                        (DocumentClass self, GlibString string) => self -> IO string-documentGetCharacterSet self-  = ({# call webkit_dom_document_get_character_set #}-       (toDocument self))-      >>=-      readUTFString--documentGetPreferredStylesheetSet ::-                                  (DocumentClass self, GlibString string) => self -> IO string-documentGetPreferredStylesheetSet self-  = ({# call webkit_dom_document_get_preferred_stylesheet_set #}-       (toDocument self))-      >>=-      readUTFString--documentSetSelectedStylesheetSet ::-                                 (DocumentClass self, GlibString string) => self -> string -> IO ()-documentSetSelectedStylesheetSet self val-  = withUTFString val $-      \ valPtr ->-        {# call webkit_dom_document_set_selected_stylesheet_set #}-          (toDocument self)-          valPtr--documentGetSelectedStylesheetSet ::-                                 (DocumentClass self, GlibString string) => self -> IO string-documentGetSelectedStylesheetSet self-  = ({# call webkit_dom_document_get_selected_stylesheet_set #}-       (toDocument self))-      >>=-      readUTFString- -documentGetCompatMode ::-                      (DocumentClass self, GlibString string) => 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, GlibString string) => 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
Graphics/UI/Gtk/WebKit/DOM/DocumentType.chs view
@@ -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, GlibString string) => 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, GlibString string) => 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, GlibString string) => 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, GlibString string) => 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)
Graphics/UI/Gtk/WebKit/DOM/Element.chs view
@@ -1,718 +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, GlibString string) =>-                      self -> string -> IO string-elementGetAttribute self name-  = (withUTFString name $-       \ namePtr ->-         {# call webkit_dom_element_get_attribute #} (toElement self)-           namePtr)-      >>=-      readUTFString- -elementSetAttribute ::-                    (ElementClass self, GlibString string) =>-                      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, GlibString string) => self -> string -> IO ()-elementRemoveAttribute self name-  = withUTFString name $-      \ namePtr ->-        {# call webkit_dom_element_remove_attribute #} (toElement self)-          namePtr- -elementGetAttributeNode ::-                        (ElementClass self, GlibString string) =>-                          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, GlibString string) =>-                              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, GlibString string) =>-                        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, GlibString string) =>-                        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, GlibString string) =>-                           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, GlibString string) =>-                                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, GlibString string) =>-                            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, GlibString string) => self -> string -> IO Bool-elementHasAttribute self name-  = toBool <$>-      (withUTFString name $-         \ namePtr ->-           {# call webkit_dom_element_has_attribute #} (toElement self)-             namePtr)- -elementHasAttributeNS ::-                      (ElementClass self, GlibString string) =>-                        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, GlibString string) =>-                                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, GlibString string) =>-                       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, GlibString string) =>-                          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, GlibString string) => 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, GlibString string) => 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, GlibString string) => self -> string -> IO ()-elementSetId self val-  = withUTFString val $-      \ valPtr ->-        {# call webkit_dom_element_set_id #} (toElement self) valPtr- -elementGetId ::-             (ElementClass self, GlibString string) => 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, GlibString string) => self -> string -> IO ()-elementSetClassName self val-  = withUTFString val $-      \ valPtr ->-        {# call webkit_dom_element_set_class_name #} (toElement self)-          valPtr- -elementGetClassName ::-                    (ElementClass self, GlibString string) => 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, GlibString string) => 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"
+ Graphics/UI/Gtk/WebKit/DOM/Enums.hs view
@@ -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
Graphics/UI/Gtk/WebKit/DOM/Event.chs view
@@ -1,124 +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, GlibString string) =>-                 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)))
Graphics/UI/Gtk/WebKit/DOM/EventM.hs view
@@ -1,8 +1,11 @@ module Graphics.UI.Gtk.WebKit.DOM.EventM (-  Signal (..)-, EventM (..)-, target+  EventM (..)+, EventName (..)+, newListener+, addListener+, removeListener+, on , event , eventTarget , eventCurrentTarget@@ -53,214 +56,219 @@ , mouseXY , mouseFromElement , mouseToElement-, connect ) where+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) -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 qualified Data.Text as T (pack)+type EventM t e = ReaderT e IO -type Signal target callback = target -> callback -> IO (IO ())+newListener :: (EventClass e) => EventM t e () -> IO (SaferEventListener t e)+newListener f = SaferEventListener <$> eventListenerNew (runReaderT f) -type EventM e t a = ReaderT (t, e) IO a+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 -target :: EventM e t t-target = fst <$> 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 -event :: EventM e t e-event = snd <$> ask+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) -eventTarget :: EventClass e => EventM e t (Maybe EventTarget)-eventTarget = event >>= (liftIO . eventGetTarget)+target :: (EventClass e, GObjectClass t) => EventM t e (Maybe t)+target = (fmap (unsafeCastGObject . toGObject)) <$> (ask >>= Event.getTarget) -eventCurrentTarget :: EventClass e => EventM e t (Maybe EventTarget)-eventCurrentTarget = event >>= (liftIO . eventGetCurrentTarget)+event :: EventM t e e+event = ask -eventPhase :: EventClass e => EventM e t Word-eventPhase = event >>= (liftIO . eventGetEventPhase)+eventTarget :: EventClass e => EventM t e (Maybe EventTarget)+eventTarget = event >>= Event.getTarget -bubbles :: EventClass e => EventM e t Bool-bubbles = event >>= (liftIO . eventGetBubbles)+eventCurrentTarget :: EventClass e => EventM t e (Maybe EventTarget)+eventCurrentTarget = event >>= Event.getCurrentTarget -cancelable :: EventClass e => EventM e t Bool-cancelable = event >>= (liftIO . eventGetCancelable)+eventPhase :: EventClass e => EventM t e Word+eventPhase = event >>= Event.getEventPhase -timeStamp :: EventClass e => EventM e t Word-timeStamp = event >>= (liftIO . eventGetTimeStamp)+bubbles :: EventClass e => EventM t e Bool+bubbles = event >>= Event.getBubbles -stopPropagation :: EventClass e => EventM e t ()-stopPropagation = event >>= (liftIO . eventStopPropagation)+cancelable :: EventClass e => EventM t e Bool+cancelable = event >>= Event.getCancelable -preventDefault :: EventClass e => EventM e t ()-preventDefault = event >>= (liftIO . eventPreventDefault)+timeStamp :: EventClass e => EventM t e Word+timeStamp = event >>= Event.getTimeStamp -defaultPrevented :: EventClass e => EventM e t Bool-defaultPrevented = event >>= (liftIO . eventGetDefaultPrevented)+stopPropagation :: EventClass e => EventM t e ()+stopPropagation = event >>= Event.stopPropagation -stopImmediatePropagation :: EventClass e => EventM e t ()-stopImmediatePropagation = event >>= (liftIO . eventStopImmediatePropagation)+preventDefault :: EventClass e => EventM t e ()+preventDefault = event >>= Event.preventDefault -srcElement :: EventClass e => EventM e t (Maybe EventTarget)-srcElement = event >>= (liftIO . eventGetSrcElement)+defaultPrevented :: EventClass e => EventM t e Bool+defaultPrevented = event >>= Event.getDefaultPrevented -getCancelBubble :: EventClass e => EventM e t Bool-getCancelBubble = event >>= (liftIO . eventGetCancelBubble)+stopImmediatePropagation :: EventClass e => EventM t e ()+stopImmediatePropagation = event >>= Event.stopImmediatePropagation -cancelBubble :: EventClass e => Bool -> EventM e t ()-cancelBubble f = event >>= (liftIO . flip eventSetCancelBubble f)+srcElement :: EventClass e => EventM t e (Maybe EventTarget)+srcElement = event >>= Event.getSrcElement -getReturnValue :: EventClass e => EventM e t Bool-getReturnValue = event >>= (liftIO . eventGetReturnValue)+getCancelBubble :: EventClass e => EventM t e Bool+getCancelBubble = event >>= Event.getCancelBubble -returnValue :: EventClass e => Bool -> EventM e t ()-returnValue f = event >>= (liftIO . flip eventSetReturnValue f)+cancelBubble :: EventClass e => Bool -> EventM t e ()+cancelBubble f = event >>= flip Event.setCancelBubble f -uiView :: UIEventClass e => EventM e t (Maybe DOMWindow)-uiView = event >>= (liftIO . uiEventGetView)+getReturnValue :: EventClass e => EventM t e Bool+getReturnValue = event >>= Event.getReturnValue -uiDetail :: UIEventClass e => EventM e t Int-uiDetail = event >>= (liftIO . uiEventGetDetail)+returnValue :: EventClass e => Bool -> EventM t e ()+returnValue f = event >>= flip Event.setReturnValue f -uiKeyCode :: UIEventClass e => EventM e t Int-uiKeyCode = event >>= (liftIO . uiEventGetKeyCode)+uiView :: UIEventClass e => EventM t e (Maybe Window)+uiView = event >>= UIEvent.getView -uiCharCode :: UIEventClass e => EventM e t Int-uiCharCode = event >>= (liftIO . uiEventGetCharCode)+uiDetail :: UIEventClass e => EventM t e Int+uiDetail = event >>= UIEvent.getDetail -uiLayerX :: UIEventClass e => EventM e t Int-uiLayerX = event >>= (liftIO . uiEventGetLayerX)+uiKeyCode :: UIEventClass e => EventM t e Int+uiKeyCode = event >>= UIEvent.getKeyCode -uiLayerY :: UIEventClass e => EventM e t Int-uiLayerY = event >>= (liftIO . uiEventGetLayerY)+uiCharCode :: UIEventClass e => EventM t e Int+uiCharCode = event >>= UIEvent.getCharCode -uiLayerXY :: UIEventClass e => EventM e t (Int, Int)+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) -mouseMovementX :: MouseEventClass e => EventM e t Int-mouseMovementX = event >>= (liftIO . mouseEventGetMovementX)+mouseMovementX :: MouseEventClass e => EventM t e Int+mouseMovementX = event >>= MouseEvent.getMovementX -mouseMovementY :: MouseEventClass e => EventM e t Int-mouseMovementY = event >>= (liftIO . mouseEventGetMovementY)+mouseMovementY :: MouseEventClass e => EventM t e Int+mouseMovementY = event >>= MouseEvent.getMovementY -mouseMovementXY :: MouseEventClass e => EventM e t (Int, Int)+mouseMovementXY :: MouseEventClass e => EventM t e (Int, Int) mouseMovementXY = do-  e <- event-  liftIO $ do-    x <- mouseEventGetMovementX e-    y <- mouseEventGetMovementY e+    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 (T.pack eventName) False $ curry (runReaderT callback)
+ Graphics/UI/Gtk/WebKit/DOM/EventTarget.chs view
@@ -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_
Graphics/UI/Gtk/WebKit/DOM/EventTargetClosures.chs view
@@ -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,48 @@ 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, GlibString string) =>-                           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 sptr) = do+  g_closure_unref gclosurePtr+  freeStablePtr sptr+
− Graphics/UI/Gtk/WebKit/DOM/Events.chs 
@@ -1,7 +0,0 @@-module Graphics.UI.Gtk.WebKit.DOM.Events (Event, EventClass) where- -data Event = Event- -class EventClass a- -instance EventClass Event
Graphics/UI/Gtk/WebKit/DOM/File.chs view
@@ -1,28 +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, GlibString string) => 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, GlibString string) => 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
Graphics/UI/Gtk/WebKit/DOM/FileList.chs view
@@ -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)))
Graphics/UI/Gtk/WebKit/DOM/Geolocation.chs view
@@ -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))
Graphics/UI/Gtk/WebKit/DOM/HTMLAnchorElement.chs view
@@ -1,389 +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, GlibString string) =>-                              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, GlibString string) =>-                              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, GlibString string) =>-                             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, GlibString string) =>-                             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, GlibString string) =>-                               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, GlibString string) =>-                               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, GlibString string) =>-                           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, GlibString string) =>-                           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, GlibString string) =>-                               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, GlibString string) =>-                               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, GlibString string) =>-                           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, GlibString string) =>-                           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, GlibString string) =>-                           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, GlibString string) =>-                           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, GlibString string) =>-                          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, GlibString string) =>-                          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, GlibString string) =>-                          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, GlibString string) =>-                          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, GlibString string) =>-                            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, GlibString string) =>-                            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, GlibString string) =>-                             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, GlibString string) =>-                             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, GlibString string) =>-                           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, GlibString string) =>-                           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, GlibString string) =>-                           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, GlibString string) =>-                           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, GlibString string) =>-                               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, GlibString string) =>-                               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, GlibString string) =>-                               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, GlibString string) =>-                               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, GlibString string) =>-                           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, GlibString string) =>-                           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, GlibString string) =>-                               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, GlibString string) =>-                               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, GlibString string) =>-                             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, GlibString string) =>-                             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, GlibString string) =>-                             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, GlibString string) =>-                           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
Graphics/UI/Gtk/WebKit/DOM/HTMLAppletElement.chs view
@@ -1,220 +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, GlibString string) =>-                            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, GlibString string) =>-                            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, GlibString string) =>-                          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, GlibString string) =>-                          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, GlibString string) =>-                              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, GlibString string) =>-                              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, GlibString string) =>-                           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, GlibString string) =>-                           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, GlibString string) =>-                               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, GlibString string) =>-                               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, GlibString string) =>-                             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, GlibString string) =>-                             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, GlibString string) =>-                           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, GlibString string) =>-                           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, GlibString string) =>-                             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, GlibString string) =>-                             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, GlibString string) =>-                            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, GlibString string) =>-                            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)
Graphics/UI/Gtk/WebKit/DOM/HTMLAreaElement.chs view
@@ -1,198 +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, GlibString string) =>-                        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, GlibString string) => 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, GlibString string) =>-                           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, GlibString string) => 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, GlibString string) =>-                         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, GlibString string) => 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, GlibString string) =>-                         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, GlibString string) => 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, GlibString string) =>-                          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, GlibString string) => 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, GlibString string) =>-                           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, GlibString string) => 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, GlibString string) => 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, GlibString string) => 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, GlibString string) => 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, GlibString string) => 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, GlibString string) => 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, GlibString string) => 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, GlibString string) => 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
Graphics/UI/Gtk/WebKit/DOM/HTMLBRElement.chs view
@@ -1,29 +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, GlibString string) =>-                        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, GlibString string) => 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)
Graphics/UI/Gtk/WebKit/DOM/HTMLBaseElement.chs view
@@ -1,48 +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, GlibString string) =>-                         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, GlibString string) => 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, GlibString string) =>-                           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, GlibString string) => 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)
Graphics/UI/Gtk/WebKit/DOM/HTMLBaseFontElement.chs view
@@ -1,66 +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, GlibString string) =>-                              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, GlibString string) =>-                              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, GlibString string) =>-                             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, GlibString string) =>-                             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)))
Graphics/UI/Gtk/WebKit/DOM/HTMLBodyElement.chs view
@@ -1,188 +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, GlibString string) =>-                          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, GlibString string) => 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, GlibString string) =>-                               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, GlibString string) => 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, GlibString string) =>-                            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, GlibString string) => 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, GlibString string) =>-                         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, GlibString string) => 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, GlibString string) =>-                         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, GlibString string) => 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, GlibString string) =>-                          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, GlibString string) => 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"
Graphics/UI/Gtk/WebKit/DOM/HTMLButtonElement.chs view
@@ -1,234 +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, GlibString string) =>-                                     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, GlibString string) =>-                                 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, GlibString string) =>-                                 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, GlibString string) =>-                                  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, GlibString string) =>-                                  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, GlibString string) =>-                                 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, GlibString string) =>-                                 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, GlibString string) =>-                                 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, GlibString string) =>-                                 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, GlibString string) =>-                           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, GlibString string) =>-                           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, GlibString string) =>-                            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, GlibString string) =>-                            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, GlibString string) =>-                                        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)))
Graphics/UI/Gtk/WebKit/DOM/HTMLCanvasElement.chs view
@@ -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)))
Graphics/UI/Gtk/WebKit/DOM/HTMLCollection.chs view
@@ -1,41 +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, GlibString string) =>-                          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)))
Graphics/UI/Gtk/WebKit/DOM/HTMLDListElement.chs view
@@ -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)))
Graphics/UI/Gtk/WebKit/DOM/HTMLDetailsElement.chs view
@@ -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)))
Graphics/UI/Gtk/WebKit/DOM/HTMLDirectoryElement.chs view
@@ -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)))
Graphics/UI/Gtk/WebKit/DOM/HTMLDivElement.chs view
@@ -1,29 +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, GlibString string) =>-                         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, GlibString string) => 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)
Graphics/UI/Gtk/WebKit/DOM/HTMLDocument.chs view
@@ -1,221 +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, GlibString string) =>-                     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, GlibString string) => 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, GlibString string) =>-                            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, GlibString string) => 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, GlibString string) => 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, GlibString string) =>-                         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, GlibString string) => 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, GlibString string) =>-                         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, GlibString string) => 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, GlibString string) =>-                            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, GlibString string) => 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, GlibString string) =>-                           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, GlibString string) => 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, GlibString string) =>-                            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, GlibString string) => 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)
Graphics/UI/Gtk/WebKit/DOM/HTMLElement.chs view
@@ -1,351 +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, GlibString string) =>-                                   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, GlibString string) =>-                                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, GlibString string) =>-                                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, GlibString string) =>-                      self -> string -> IO ()-htmlElementSetTitle self val-  = withUTFString val $-      \ valPtr ->-        {# call webkit_dom_html_element_set_title #} (toHTMLElement self)-          valPtr- -htmlElementGetTitle ::-                    (HTMLElementClass self, GlibString string) => self -> IO string-htmlElementGetTitle self-  = ({# call webkit_dom_html_element_get_title #}-       (toHTMLElement self))-      >>=-      readUTFString- -htmlElementSetLang ::-                   (HTMLElementClass self, GlibString string) =>-                     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, GlibString string) => 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, GlibString string) =>-                    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, GlibString string) => 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, GlibString string) =>-                               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, GlibString string) => 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, GlibString string) =>-                          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, GlibString string) => 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, GlibString string) =>-                          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, GlibString string) => 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, GlibString string) =>-                          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, GlibString string) => 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, GlibString string) =>-                          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, GlibString string) => 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, GlibString string) =>-                          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, GlibString string) => 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, GlibString string) =>-                                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, GlibString string) => 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)))
Graphics/UI/Gtk/WebKit/DOM/HTMLEmbedElement.chs view
@@ -1,100 +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, GlibString string) =>-                           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, GlibString string) =>-                           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, GlibString string) =>-                          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, GlibString string) =>-                          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, GlibString string) =>-                         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, GlibString string) =>-                         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)))
Graphics/UI/Gtk/WebKit/DOM/HTMLFieldSetElement.chs view
@@ -1,116 +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, GlibString string) =>-                                       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, GlibString string) =>-                             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, GlibString string) =>-                             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, GlibString string) =>-                                          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)
Graphics/UI/Gtk/WebKit/DOM/HTMLFontElement.chs view
@@ -1,67 +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, GlibString string) =>-                          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, GlibString string) => 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, GlibString string) =>-                         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, GlibString string) => 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, GlibString string) =>-                         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, GlibString string) => 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)
Graphics/UI/Gtk/WebKit/DOM/HTMLFormElement.chs view
@@ -1,212 +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, GlibString string) =>-                                  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, GlibString string) => 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, GlibString string) =>-                           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, GlibString string) => 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, GlibString string) =>-                                 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, GlibString string) => 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, GlibString string) =>-                            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, GlibString string) => 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, GlibString string) =>-                             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, GlibString string) => 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, GlibString string) =>-                           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, GlibString string) => 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, GlibString string) =>-                         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, GlibString string) => 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, GlibString string) =>-                           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, GlibString string) => 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"
Graphics/UI/Gtk/WebKit/DOM/HTMLFrameElement.chs view
@@ -1,195 +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, GlibString string) =>-                                 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, GlibString string) =>-                                 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, GlibString string) =>-                              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, GlibString string) =>-                              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, GlibString string) =>-                                  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, GlibString string) =>-                                  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, GlibString string) =>-                                 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, GlibString string) =>-                                 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, GlibString string) =>-                          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, GlibString string) =>-                          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, GlibString string) =>-                               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, GlibString string) =>-                               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, GlibString string) =>-                         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, GlibString string) =>-                         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)))
Graphics/UI/Gtk/WebKit/DOM/HTMLFrameSetElement.chs view
@@ -1,129 +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, GlibString string) =>-                             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, GlibString string) =>-                             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, GlibString string) =>-                             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, GlibString string) =>-                             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"
Graphics/UI/Gtk/WebKit/DOM/HTMLHRElement.chs view
@@ -1,81 +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, GlibString string) =>-                        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, GlibString string) => 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, GlibString string) =>-                       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, GlibString string) => 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, GlibString string) =>-                        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, GlibString string) => 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)
Graphics/UI/Gtk/WebKit/DOM/HTMLHeadElement.chs view
@@ -1,29 +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, GlibString string) =>-                            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, GlibString string) => 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)
Graphics/UI/Gtk/WebKit/DOM/HTMLHeadingElement.chs view
@@ -1,31 +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, GlibString string) =>-                             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, GlibString string) =>-                             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)
Graphics/UI/Gtk/WebKit/DOM/HTMLHtmlElement.chs view
@@ -1,48 +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, GlibString string) =>-                            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, GlibString string) => 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, GlibString string) =>-                             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, GlibString string) => 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)
Graphics/UI/Gtk/WebKit/DOM/HTMLIFrameElement.chs view
@@ -1,289 +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, GlibString string) =>-                            self -> string -> IO ()-htmliFrameElementSetAlign self val-  = withUTFString val $-      \ valPtr ->-        {# call webkit_dom_html_iframe_element_set_align #}-          (toHTMLIFrameElement self)-          valPtr- -htmliFrameElementGetAlign ::-                          (HTMLIFrameElementClass self, GlibString string) =>-                            self -> IO string-htmliFrameElementGetAlign self-  = ({# call webkit_dom_html_iframe_element_get_align #}-       (toHTMLIFrameElement self))-      >>=-      readUTFString- -htmliFrameElementSetFrameBorder ::-                                (HTMLIFrameElementClass self, GlibString string) =>-                                  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, GlibString string) =>-                                  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, GlibString string) =>-                             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, GlibString string) =>-                             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, GlibString string) =>-                               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, GlibString string) =>-                               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, GlibString string) =>-                                   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, GlibString string) =>-                                   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, GlibString string) =>-                                  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, GlibString string) =>-                                  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, GlibString string) =>-                           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, GlibString string) =>-                           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, GlibString string) =>-                              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, GlibString string) =>-                              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, GlibString string) =>-                                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, GlibString string) =>-                                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, GlibString string) =>-                          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, GlibString string) =>-                          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, GlibString string) =>-                             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, GlibString string) =>-                             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, GlibString string) =>-                            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, GlibString string) =>-                            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)))
Graphics/UI/Gtk/WebKit/DOM/HTMLImageElement.chs view
@@ -1,326 +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, GlibString string) =>-                          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, GlibString string) =>-                          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, GlibString string) =>-                           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, GlibString string) =>-                           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, GlibString string) =>-                         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, GlibString string) =>-                         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, GlibString string) =>-                            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, GlibString string) =>-                            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, GlibString string) =>-                                 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, GlibString string) =>-                                 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, GlibString string) =>-                              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, GlibString string) =>-                              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, GlibString string) =>-                         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, GlibString string) =>-                         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, GlibString string) =>-                            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, GlibString string) =>-                            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, GlibString string) =>-                            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, GlibString string) =>-                            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, GlibString string) =>-                            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, GlibString string) =>-                            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)))
Graphics/UI/Gtk/WebKit/DOM/HTMLInputElement.chs view
@@ -1,858 +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, GlibString string) =>-                                    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, GlibString string) =>-                               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, GlibString string) =>-                                  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, GlibString string) =>-                            self -> string -> IO ()-htmlInputElementSetAccept self val-  = withUTFString val $-      \ valPtr ->-        {# call webkit_dom_html_input_element_set_accept #}-          (toHTMLInputElement self)-          valPtr--htmlInputElementGetAccept ::-                          (HTMLInputElementClass self, GlibString string) =>-                            self -> IO string-htmlInputElementGetAccept self-  = ({# call webkit_dom_html_input_element_get_accept #}-       (toHTMLInputElement self))-      >>=-      readUTFString--htmlInputElementSetAlt ::-                       (HTMLInputElementClass self, GlibString string) =>-                         self -> string -> IO ()-htmlInputElementSetAlt self val-  = withUTFString val $-      \ valPtr ->-        {# call webkit_dom_html_input_element_set_alt #}-          (toHTMLInputElement self)-          valPtr--htmlInputElementGetAlt ::-                       (HTMLInputElementClass self, GlibString string) =>-                         self -> IO string-htmlInputElementGetAlt self-  = ({# call webkit_dom_html_input_element_get_alt #}-       (toHTMLInputElement self))-      >>=-      readUTFString--htmlInputElementSetAutocomplete ::-                                (HTMLInputElementClass self, GlibString string) =>-                                  self -> string -> IO ()-htmlInputElementSetAutocomplete self val-  = withUTFString val $-      \ valPtr ->-        {# call webkit_dom_html_input_element_set_autocomplete #}-          (toHTMLInputElement self)-          valPtr--htmlInputElementGetAutocomplete ::-                                (HTMLInputElementClass self, GlibString string) =>-                                  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, GlibString string) =>-                             self -> string -> IO ()-htmlInputElementSetDirName self val-  = withUTFString val $-      \ valPtr ->-        {# call webkit_dom_html_input_element_set_dir_name #}-          (toHTMLInputElement self)-          valPtr--htmlInputElementGetDirName ::-                           (HTMLInputElementClass self, GlibString string) =>-                             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, GlibString string) =>-                                self -> string -> IO ()-htmlInputElementSetFormAction self val-  = withUTFString val $-      \ valPtr ->-        {# call webkit_dom_html_input_element_set_form_action #}-          (toHTMLInputElement self)-          valPtr--htmlInputElementGetFormAction ::-                              (HTMLInputElementClass self, GlibString string) =>-                                self -> IO string-htmlInputElementGetFormAction self-  = ({# call webkit_dom_html_input_element_get_form_action #}-       (toHTMLInputElement self))-      >>=-      readUTFString--htmlInputElementSetFormEnctype ::-                               (HTMLInputElementClass self, GlibString string) =>-                                 self -> string -> IO ()-htmlInputElementSetFormEnctype self val-  = withUTFString val $-      \ valPtr ->-        {# call webkit_dom_html_input_element_set_form_enctype #}-          (toHTMLInputElement self)-          valPtr--htmlInputElementGetFormEnctype ::-                               (HTMLInputElementClass self, GlibString string) =>-                                 self -> IO string-htmlInputElementGetFormEnctype self-  = ({# call webkit_dom_html_input_element_get_form_enctype #}-       (toHTMLInputElement self))-      >>=-      readUTFString--htmlInputElementSetFormMethod ::-                              (HTMLInputElementClass self, GlibString string) =>-                                self -> string -> IO ()-htmlInputElementSetFormMethod self val-  = withUTFString val $-      \ valPtr ->-        {# call webkit_dom_html_input_element_set_form_method #}-          (toHTMLInputElement self)-          valPtr--htmlInputElementGetFormMethod ::-                              (HTMLInputElementClass self, GlibString string) =>-                                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, GlibString string) =>-                                self -> string -> IO ()-htmlInputElementSetFormTarget self val-  = withUTFString val $-      \ valPtr ->-        {# call webkit_dom_html_input_element_set_form_target #}-          (toHTMLInputElement self)-          valPtr--htmlInputElementGetFormTarget ::-                              (HTMLInputElementClass self, GlibString string) =>-                                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, GlibString string) =>-                         self -> string -> IO ()-htmlInputElementSetMax self val-  = withUTFString val $-      \ valPtr ->-        {# call webkit_dom_html_input_element_set_max #}-          (toHTMLInputElement self)-          valPtr--htmlInputElementGetMax ::-                       (HTMLInputElementClass self, GlibString string) =>-                         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, GlibString string) =>-                         self -> string -> IO ()-htmlInputElementSetMin self val-  = withUTFString val $-      \ valPtr ->-        {# call webkit_dom_html_input_element_set_min #}-          (toHTMLInputElement self)-          valPtr--htmlInputElementGetMin ::-                       (HTMLInputElementClass self, GlibString string) =>-                         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, GlibString string) =>-                          self -> string -> IO ()-htmlInputElementSetName self val-  = withUTFString val $-      \ valPtr ->-        {# call webkit_dom_html_input_element_set_name #}-          (toHTMLInputElement self)-          valPtr--htmlInputElementGetName ::-                        (HTMLInputElementClass self, GlibString string) =>-                          self -> IO string-htmlInputElementGetName self-  = ({# call webkit_dom_html_input_element_get_name #}-       (toHTMLInputElement self))-      >>=-      readUTFString--htmlInputElementSetPattern ::-                           (HTMLInputElementClass self, GlibString string) =>-                             self -> string -> IO ()-htmlInputElementSetPattern self val-  = withUTFString val $-      \ valPtr ->-        {# call webkit_dom_html_input_element_set_pattern #}-          (toHTMLInputElement self)-          valPtr--htmlInputElementGetPattern ::-                           (HTMLInputElementClass self, GlibString string) =>-                             self -> IO string-htmlInputElementGetPattern self-  = ({# call webkit_dom_html_input_element_get_pattern #}-       (toHTMLInputElement self))-      >>=-      readUTFString--htmlInputElementSetPlaceholder ::-                               (HTMLInputElementClass self, GlibString string) =>-                                 self -> string -> IO ()-htmlInputElementSetPlaceholder self val-  = withUTFString val $-      \ valPtr ->-        {# call webkit_dom_html_input_element_set_placeholder #}-          (toHTMLInputElement self)-          valPtr--htmlInputElementGetPlaceholder ::-                               (HTMLInputElementClass self, GlibString string) =>-                                 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, GlibString string) =>-                         self -> string -> IO ()-htmlInputElementSetSrc self val-  = withUTFString val $-      \ valPtr ->-        {# call webkit_dom_html_input_element_set_src #}-          (toHTMLInputElement self)-          valPtr--htmlInputElementGetSrc ::-                       (HTMLInputElementClass self, GlibString string) =>-                         self -> IO string-htmlInputElementGetSrc self-  = ({# call webkit_dom_html_input_element_get_src #}-       (toHTMLInputElement self))-      >>=-      readUTFString--htmlInputElementSetStep ::-                        (HTMLInputElementClass self, GlibString string) =>-                          self -> string -> IO ()-htmlInputElementSetStep self val-  = withUTFString val $-      \ valPtr ->-        {# call webkit_dom_html_input_element_set_step #}-          (toHTMLInputElement self)-          valPtr--htmlInputElementGetStep ::-                        (HTMLInputElementClass self, GlibString string) =>-                          self -> IO string-htmlInputElementGetStep self-  = ({# call webkit_dom_html_input_element_get_step #}-       (toHTMLInputElement self))-      >>=-      readUTFString--htmlInputElementSetDefaultValue ::-                                (HTMLInputElementClass self, GlibString string) =>-                                  self -> string -> IO ()-htmlInputElementSetDefaultValue self val-  = withUTFString val $-      \ valPtr ->-        {# call webkit_dom_html_input_element_set_default_value #}-          (toHTMLInputElement self)-          valPtr--htmlInputElementGetDefaultValue ::-                                (HTMLInputElementClass self, GlibString string) =>-                                  self -> IO string-htmlInputElementGetDefaultValue self-  = ({# call webkit_dom_html_input_element_get_default_value #}-       (toHTMLInputElement self))-      >>=-      readUTFString--htmlInputElementSetValue ::-                         (HTMLInputElementClass self, GlibString string) =>-                           self -> string -> IO ()-htmlInputElementSetValue self val-  = withUTFString val $-      \ valPtr ->-        {# call webkit_dom_html_input_element_set_value #}-          (toHTMLInputElement self)-          valPtr--htmlInputElementGetValue ::-                         (HTMLInputElementClass self, GlibString string) =>-                           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, GlibString string) =>-                                       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, GlibString string) =>-                           self -> string -> IO ()-htmlInputElementSetAlign self val-  = withUTFString val $-      \ valPtr ->-        {# call webkit_dom_html_input_element_set_align #}-          (toHTMLInputElement self)-          valPtr--htmlInputElementGetAlign ::-                         (HTMLInputElementClass self, GlibString string) =>-                           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, GlibString string) =>-                            self -> string -> IO ()-htmlInputElementSetUseMap self val-  = withUTFString val $-      \ valPtr ->-        {# call webkit_dom_html_input_element_set_use_map #}-          (toHTMLInputElement self)-          valPtr--htmlInputElementGetUseMap ::-                          (HTMLInputElementClass self, GlibString string) =>-                            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, GlibString string) =>-                             self -> string -> IO ()-htmlInputElementSetCapture self val-  = withUTFString val $-      \ valPtr ->-        {# call webkit_dom_html_input_element_set_capture #}-          (toHTMLInputElement self)-          valPtr--htmlInputElementGetCapture ::-                           (HTMLInputElementClass self, GlibString string) =>-                             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
Graphics/UI/Gtk/WebKit/DOM/HTMLKeygenElement.chs view
@@ -1,158 +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, GlibString string) =>-                                     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, GlibString string) =>-                                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, GlibString string) =>-                                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, GlibString string) =>-                              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, GlibString string) =>-                              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, GlibString string) =>-                           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, GlibString string) =>-                           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, GlibString string) =>-                                        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)))
Graphics/UI/Gtk/WebKit/DOM/HTMLLIElement.chs view
@@ -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)))
Graphics/UI/Gtk/WebKit/DOM/HTMLLabelElement.chs view
@@ -1,45 +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, GlibString string) =>-                             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, GlibString string) =>-                             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)))
Graphics/UI/Gtk/WebKit/DOM/HTMLLegendElement.chs view
@@ -1,38 +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, GlibString string) =>-                            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, GlibString string) =>-                            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)
Graphics/UI/Gtk/WebKit/DOM/HTMLLinkElement.chs view
@@ -1,165 +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, GlibString string) =>-                            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, GlibString string) => 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, GlibString string) =>-                         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, GlibString string) => 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, GlibString string) =>-                             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, GlibString string) => 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, GlibString string) =>-                          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, GlibString string) => 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, GlibString string) =>-                        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, GlibString string) => 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, GlibString string) =>-                        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, GlibString string) => 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, GlibString string) =>-                           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, GlibString string) => 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
Graphics/UI/Gtk/WebKit/DOM/HTMLMapElement.chs view
@@ -1,36 +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, GlibString string) =>-                        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, GlibString string) => 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)
Graphics/UI/Gtk/WebKit/DOM/HTMLMarqueeElement.chs view
@@ -1,224 +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, GlibString string) =>-                                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, GlibString string) =>-                                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, GlibString string) =>-                               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, GlibString string) =>-                               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, GlibString string) =>-                                 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, GlibString string) =>-                                 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, GlibString string) =>-                              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, GlibString string) =>-                              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, GlibString string) =>-                             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, GlibString string) =>-                             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)
Graphics/UI/Gtk/WebKit/DOM/HTMLMediaElement.chs view
@@ -1,442 +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, GlibString string) =>-                              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, GlibString string) =>-                         self -> string -> IO ()-htmlMediaElementSetSrc self val-  = withUTFString val $-      \ valPtr ->-        {# call webkit_dom_html_media_element_set_src #}-          (toHTMLMediaElement self)-          valPtr--htmlMediaElementGetSrc ::-                       (HTMLMediaElementClass self, GlibString string) =>-                         self -> IO string-htmlMediaElementGetSrc self-  = ({# call webkit_dom_html_media_element_get_src #}-       (toHTMLMediaElement self))-      >>=-      readUTFString--htmlMediaElementGetCurrentSrc ::-                              (HTMLMediaElementClass self, GlibString string) =>-                                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, GlibString string) =>-                             self -> string -> IO ()-htmlMediaElementSetPreload self val-  = withUTFString val $-      \ valPtr ->-        {# call webkit_dom_html_media_element_set_preload #}-          (toHTMLMediaElement self)-          valPtr--htmlMediaElementGetPreload ::-                           (HTMLMediaElementClass self, GlibString string) =>-                             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, GlibString string) =>-                                self -> string -> IO ()-htmlMediaElementSetMediaGroup self val-  = withUTFString val $-      \ valPtr ->-        {# call webkit_dom_html_media_element_set_media_group #}-          (toHTMLMediaElement self)-          valPtr--htmlMediaElementGetMediaGroup ::-                              (HTMLMediaElementClass self, GlibString string) =>-                                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
Graphics/UI/Gtk/WebKit/DOM/HTMLMenuElement.chs view
@@ -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)))
Graphics/UI/Gtk/WebKit/DOM/HTMLMetaElement.chs view
@@ -1,86 +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, GlibString string) =>-                            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, GlibString string) => 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, GlibString string) =>-                              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, GlibString string) => 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, GlibString string) =>-                         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, GlibString string) => 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, GlibString string) =>-                           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, GlibString string) => 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)
Graphics/UI/Gtk/WebKit/DOM/HTMLModElement.chs view
@@ -1,48 +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, GlibString string) =>-                        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, GlibString string) => 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, GlibString string) =>-                            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, GlibString string) => 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)
Graphics/UI/Gtk/WebKit/DOM/HTMLOListElement.chs view
@@ -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)))
Graphics/UI/Gtk/WebKit/DOM/HTMLObjectElement.chs view
@@ -1,354 +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, GlibString string) =>-                                     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, GlibString string) =>-                           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, GlibString string) =>-                           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, GlibString string) =>-                            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, GlibString string) =>-                            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, GlibString string) =>-                              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, GlibString string) =>-                              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, GlibString string) =>-                             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, GlibString string) =>-                             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, GlibString string) =>-                               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, GlibString string) =>-                               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, GlibString string) =>-                               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, GlibString string) =>-                               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, GlibString string) =>-                           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, GlibString string) =>-                           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, GlibString string) =>-                             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, GlibString string) =>-                             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, GlibString string) =>-                           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, GlibString string) =>-                           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, GlibString string) =>-                              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, GlibString string) =>-                              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, GlibString string) =>-                             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, GlibString string) =>-                             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, GlibString string) =>-                            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, GlibString string) =>-                            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, GlibString string) =>-                                        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)))
Graphics/UI/Gtk/WebKit/DOM/HTMLOptGroupElement.chs view
@@ -1,46 +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, GlibString string) =>-                              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, GlibString string) =>-                              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)
Graphics/UI/Gtk/WebKit/DOM/HTMLOptionElement.chs view
@@ -1,120 +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, GlibString string) =>-                            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, GlibString string) =>-                            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, GlibString string) =>-                            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, GlibString string) =>-                            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, GlibString string) =>-                           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)))
Graphics/UI/Gtk/WebKit/DOM/HTMLOptionsCollection.chs view
@@ -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, GlibString string) =>-                                 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)))
Graphics/UI/Gtk/WebKit/DOM/HTMLParagraphElement.chs view
@@ -1,31 +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, GlibString string) =>-                               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, GlibString string) =>-                               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)
Graphics/UI/Gtk/WebKit/DOM/HTMLParamElement.chs view
@@ -1,70 +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, GlibString string) =>-                          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, GlibString string) =>-                          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, GlibString string) =>-                           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, GlibString string) =>-                           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, GlibString string) =>-                               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, GlibString string) =>-                               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)
Graphics/UI/Gtk/WebKit/DOM/HTMLPreElement.chs view
@@ -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)))
Graphics/UI/Gtk/WebKit/DOM/HTMLQuoteElement.chs view
@@ -1,30 +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, GlibString string) =>-                          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, GlibString string) =>-                          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)
Graphics/UI/Gtk/WebKit/DOM/HTMLScriptElement.chs view
@@ -1,184 +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, GlibString string) =>-                           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, GlibString string) =>-                           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, GlibString string) =>-                              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, GlibString string) =>-                              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, GlibString string) =>-                            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, GlibString string) =>-                            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, GlibString string) =>-                              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, GlibString string) =>-                              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, GlibString string) =>-                          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, GlibString string) =>-                          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, GlibString string) =>-                                  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, GlibString string) =>-                                  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, GlibString string) =>-                            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, GlibString string) =>-                            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
Graphics/UI/Gtk/WebKit/DOM/HTMLSelectElement.chs view
@@ -1,279 +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, GlibString string) =>-                             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, GlibString string) =>-                                     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, GlibString string) =>-                           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, GlibString string) =>-                           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, GlibString string) =>-                            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, GlibString string) =>-                            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, GlibString string) =>-                                        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)))
Graphics/UI/Gtk/WebKit/DOM/HTMLStyleElement.chs view
@@ -1,67 +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, GlibString string) =>-                           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, GlibString string) =>-                           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)))
Graphics/UI/Gtk/WebKit/DOM/HTMLTableCaptionElement.chs view
@@ -1,31 +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, GlibString string) =>-                                  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, GlibString string) =>-                                  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)
Graphics/UI/Gtk/WebKit/DOM/HTMLTableCellElement.chs view
@@ -1,283 +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, GlibString string) =>-                              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, GlibString string) =>-                              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, GlibString string) =>-                               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, GlibString string) =>-                               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, GlibString string) =>-                              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, GlibString string) =>-                              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, GlibString string) =>-                                 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, GlibString string) =>-                                 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, GlibString string) =>-                            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, GlibString string) =>-                            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, GlibString string) =>-                               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, GlibString string) =>-                               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, GlibString string) =>-                                 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, GlibString string) =>-                                 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, GlibString string) =>-                                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, GlibString string) =>-                                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, GlibString string) =>-                               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, GlibString string) =>-                               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, GlibString string) =>-                                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, GlibString string) =>-                                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, GlibString string) =>-                               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, GlibString string) =>-                               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)
Graphics/UI/Gtk/WebKit/DOM/HTMLTableColElement.chs view
@@ -1,126 +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, GlibString string) =>-                              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, GlibString string) =>-                              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, GlibString string) =>-                           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, GlibString string) =>-                           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, GlibString string) =>-                              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, GlibString string) =>-                              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, GlibString string) =>-                               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, GlibString string) =>-                               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, GlibString string) =>-                              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, GlibString string) =>-                              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)
Graphics/UI/Gtk/WebKit/DOM/HTMLTableElement.chs view
@@ -1,348 +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, GlibString string) =>-                           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, GlibString string) =>-                           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, GlibString string) =>-                             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, GlibString string) =>-                             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, GlibString string) =>-                            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, GlibString string) =>-                            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, GlibString string) =>-                                 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, GlibString string) =>-                                 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, GlibString string) =>-                                 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, GlibString string) =>-                                 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, GlibString string) =>-                           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, GlibString string) =>-                           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, GlibString string) =>-                           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, GlibString string) =>-                           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, GlibString string) =>-                             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, GlibString string) =>-                             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, GlibString string) =>-                           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, GlibString string) =>-                           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)
Graphics/UI/Gtk/WebKit/DOM/HTMLTableRowElement.chs view
@@ -1,158 +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, GlibString string) =>-                              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, GlibString string) =>-                              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, GlibString string) =>-                                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, GlibString string) =>-                                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, GlibString string) =>-                           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, GlibString string) =>-                           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, GlibString string) =>-                              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, GlibString string) =>-                              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, GlibString string) =>-                               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, GlibString string) =>-                               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)
Graphics/UI/Gtk/WebKit/DOM/HTMLTableSectionElement.chs view
@@ -1,123 +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, GlibString string) =>-                                  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, GlibString string) =>-                                  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, GlibString string) =>-                               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, GlibString string) =>-                               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, GlibString string) =>-                                  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, GlibString string) =>-                                  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, GlibString string) =>-                                   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, GlibString string) =>-                                   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)))
Graphics/UI/Gtk/WebKit/DOM/HTMLTextAreaElement.chs view
@@ -1,405 +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, GlibString string) =>-                                       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, GlibString string) =>-                                  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, GlibString string) =>-                                       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, GlibString string) =>-                                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, GlibString string) =>-                                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, GlibString string) =>-                             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, GlibString string) =>-                             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, GlibString string) =>-                                    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, GlibString string) =>-                                    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, GlibString string) =>-                             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, GlibString string) =>-                             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, GlibString string) =>-                                     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, GlibString string) =>-                                     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, GlibString string) =>-                              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, GlibString string) =>-                              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, GlibString string) =>-                                          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, GlibString string) =>-                                           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, GlibString string) =>-                                           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
Graphics/UI/Gtk/WebKit/DOM/HTMLTitleElement.chs view
@@ -1,30 +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, GlibString string) =>-                          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, GlibString string) =>-                          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)
Graphics/UI/Gtk/WebKit/DOM/HTMLUListElement.chs view
@@ -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)))
Graphics/UI/Gtk/WebKit/DOM/HTMLVideoElement.chs view
@@ -1,149 +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, GlibString string) =>-                            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, GlibString string) =>-                            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"
Graphics/UI/Gtk/WebKit/DOM/History.chs view
@@ -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)))
Graphics/UI/Gtk/WebKit/DOM/KeyboardEvent.chs view
@@ -1,118 +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, GlibString string) =>-                                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,-                                GlibString string) =>-                                 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, GlibString string) => 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
Graphics/UI/Gtk/WebKit/DOM/Location.chs view
@@ -1,27 +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, GlibString string) => 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
Graphics/UI/Gtk/WebKit/DOM/MediaError.chs view
@@ -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)))
Graphics/UI/Gtk/WebKit/DOM/MediaList.chs view
@@ -1,67 +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, GlibString string) =>-                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, GlibString string) => 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, GlibString string) => 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, GlibString string) => 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, GlibString string) => 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)))
Graphics/UI/Gtk/WebKit/DOM/MediaQueryList.chs view
@@ -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, GlibString string) => 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)))
+ Graphics/UI/Gtk/WebKit/DOM/MimeType.chs view
@@ -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)))
+ Graphics/UI/Gtk/WebKit/DOM/MimeTypeArray.chs view
@@ -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)))
Graphics/UI/Gtk/WebKit/DOM/MouseEvent.chs view
@@ -1,163 +1,212 @@-module Graphics.UI.Gtk.WebKit.DOM.MouseEvent-       (mouseEventInitMouseEvent, mouseEventGetScreenX,-        mouseEventGetScreenY, mouseEventGetClientX, mouseEventGetClientY,-        mouseEventGetCtrlKey, mouseEventGetShiftKey, mouseEventGetAltKey,-        mouseEventGetMetaKey, mouseEventGetButton,-        mouseEventGetRelatedTarget, mouseEventGetMovementX,-        mouseEventGetMovementY, 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, GlibString string) =>-                           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)))  -mouseEventGetMovementX :: (MouseEventClass self) => self -> IO Int-mouseEventGetMovementX 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)))  -mouseEventGetMovementY :: (MouseEventClass self) => self -> IO Int-mouseEventGetMovementY 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)))
Graphics/UI/Gtk/WebKit/DOM/NamedNodeMap.chs view
@@ -1,108 +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, GlibString string) =>-                           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, GlibString string) =>-                              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, GlibString string) =>-                             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, GlibString string) =>-                                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)))
Graphics/UI/Gtk/WebKit/DOM/Navigator.chs view
@@ -1,126 +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, GlibString string) => 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, GlibString string) => 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, GlibString string) => 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, GlibString string) => 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, GlibString string) => 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, GlibString string) => 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, GlibString string) => 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, GlibString string) => 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, GlibString string) => 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, GlibString string) => 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)))
Graphics/UI/Gtk/WebKit/DOM/Node.chs view
@@ -1,309 +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, GlibString string) =>-                  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, GlibString string) => 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, GlibString string) => 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, GlibString string) => 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, GlibString string) => self -> IO string-nodeGetNodeName self-  = ({# call webkit_dom_node_get_node_name #} (toNode self)) >>=-      readUTFString- -nodeSetNodeValue ::-                 (NodeClass self, GlibString string) => 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, GlibString string) => 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, GlibString string) => 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, GlibString string) => 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, GlibString string) => 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, GlibString string) => 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, GlibString string) => 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, GlibString string) => 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, GlibString string) => 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)))
Graphics/UI/Gtk/WebKit/DOM/NodeFilter.chs view
@@ -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
Graphics/UI/Gtk/WebKit/DOM/NodeIterator.chs view
@@ -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)))
Graphics/UI/Gtk/WebKit/DOM/NodeList.chs view
@@ -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)))
+ Graphics/UI/Gtk/WebKit/DOM/Performance.chs view
@@ -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
+ Graphics/UI/Gtk/WebKit/DOM/PerformanceNavigation.chs view
@@ -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
+ Graphics/UI/Gtk/WebKit/DOM/PerformanceTiming.chs view
@@ -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
+ Graphics/UI/Gtk/WebKit/DOM/Plugin.chs view
@@ -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)))
+ Graphics/UI/Gtk/WebKit/DOM/PluginArray.chs view
@@ -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)))
Graphics/UI/Gtk/WebKit/DOM/ProcessingInstruction.chs view
@@ -1,49 +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, GlibString string) =>-                                 self -> IO string-processingInstructionGetTarget self-  = ({# call webkit_dom_processing_instruction_get_target #}-       (toProcessingInstruction self))-      >>=-      readUTFString- -processingInstructionSetData ::-                             (ProcessingInstructionClass self, GlibString string) => 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, GlibString string) => 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)))
Graphics/UI/Gtk/WebKit/DOM/Range.chs view
@@ -1,330 +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, GlibString string) => 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, GlibString string) =>-                                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, GlibString string) => 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, GlibString string) => 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)
− Graphics/UI/Gtk/WebKit/DOM/Ranges.chs 
@@ -1,8 +0,0 @@-module Graphics.UI.Gtk.WebKit.DOM.Ranges (DOMRange, DOMRangeClass)-       where- -data DOMRange = DOMRange- -class DOMRangeClass a- -instance DOMRangeClass DOMRange
Graphics/UI/Gtk/WebKit/DOM/Screen.chs view
@@ -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)))
+ Graphics/UI/Gtk/WebKit/DOM/SecurityPolicy.chs view
@@ -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
+ Graphics/UI/Gtk/WebKit/DOM/Selection.chs view
@@ -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)))
Graphics/UI/Gtk/WebKit/DOM/Storage.chs view
@@ -1,78 +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, GlibString string) => 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, GlibString string) =>-                 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, GlibString string) => 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, GlibString string) => 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
Graphics/UI/Gtk/WebKit/DOM/StorageInfo.chs view
@@ -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
Graphics/UI/Gtk/WebKit/DOM/StyleMedia.chs view
@@ -1,20 +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, GlibString string) =>-                        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))
Graphics/UI/Gtk/WebKit/DOM/StyleSheet.chs view
@@ -1,60 +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, GlibString string) => 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, GlibString string) => 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)))
Graphics/UI/Gtk/WebKit/DOM/StyleSheetList.chs view
@@ -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)))
− Graphics/UI/Gtk/WebKit/DOM/Stylesheets.chs 
@@ -1,8 +0,0 @@-module Graphics.UI.Gtk.WebKit.DOM.Stylesheets-       (MediaList, MediaListClass) where- -data MediaList = MediaList- -class MediaListClass a- -instance MediaListClass MediaList
Graphics/UI/Gtk/WebKit/DOM/Text.chs view
@@ -1,39 +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, GlibString string) =>-                       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, GlibString string) => 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)
+ Graphics/UI/Gtk/WebKit/DOM/TextTrack.chs view
@@ -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
+ Graphics/UI/Gtk/WebKit/DOM/TextTrackCue.chs view
@@ -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
+ Graphics/UI/Gtk/WebKit/DOM/TextTrackCueList.chs view
@@ -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
+ Graphics/UI/Gtk/WebKit/DOM/TextTrackList.chs view
@@ -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
Graphics/UI/Gtk/WebKit/DOM/TimeRanges.chs view
@@ -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)))
+ Graphics/UI/Gtk/WebKit/DOM/Touch.chs view
@@ -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
− Graphics/UI/Gtk/WebKit/DOM/Traversal.chs 
@@ -1,8 +0,0 @@-module Graphics.UI.Gtk.WebKit.DOM.Traversal-       (NodeFilter, NodeFilterClass) where- -data NodeFilter = NodeFilter- -class NodeFilterClass a- -instance NodeFilterClass NodeFilter
Graphics/UI/Gtk/WebKit/DOM/TreeWalker.chs view
@@ -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)))
Graphics/UI/Gtk/WebKit/DOM/UIEvent.chs view
@@ -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, GlibString string) =>-                     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)))
Graphics/UI/Gtk/WebKit/DOM/ValidityState.chs view
@@ -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)))
+ Graphics/UI/Gtk/WebKit/DOM/VideoTrack.chs view
@@ -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
+ Graphics/UI/Gtk/WebKit/DOM/VideoTrackList.chs view
@@ -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
Graphics/UI/Gtk/WebKit/DOM/WebKitNamedFlow.chs view
@@ -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, GlibString string) => 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
Graphics/UI/Gtk/WebKit/DOM/WebKitPoint.chs view
@@ -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)))
+ Graphics/UI/Gtk/WebKit/DOM/WheelEvent.chs view
@@ -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
+ Graphics/UI/Gtk/WebKit/DOM/Window.chs view
@@ -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"
Graphics/UI/Gtk/WebKit/DOM/XPathExpression.chs view
@@ -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_))
Graphics/UI/Gtk/WebKit/DOM/XPathNSResolver.chs view
@@ -1,23 +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, GlibString string) =>-                                    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)
Graphics/UI/Gtk/WebKit/DOM/XPathResult.chs view
@@ -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, GlibString string) => 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_))
Graphics/UI/Gtk/WebKit/Download.chs view
@@ -80,7 +80,7 @@ import System.Glib.UTFString import System.Glib.GList import System.Glib.GError-import System.Glib.Attributes+import System.Glib.Attributes as G import System.Glib.Properties import Graphics.UI.Gtk.Gdk.Events @@ -237,13 +237,13 @@ -- Default value: \"\" -- -- * Since 1.1.2-destinationUri :: (DownloadClass self, GlibString string) => 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 :: DownloadClass self => G.Attr self NetworkRequest networkRequest =   newAttrFromObjectProperty "network-request"   {#call pure webkit_network_request_get_type#}@@ -252,7 +252,7 @@ -- | The NetworkResponse instance associated with the download. -- -- * Since 1.1.16-networkResponse :: DownloadClass self => Attr self NetworkResponse+networkResponse :: DownloadClass self => G.Attr self NetworkResponse networkResponse =   newAttrFromObjectProperty "network-response"   {#call pure webkit_network_response_get_type#}
+ Graphics/UI/Gtk/WebKit/GtkInternals.hs view
@@ -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)
Graphics/UI/Gtk/WebKit/Signals.chs view
@@ -67,10 +67,10 @@      ) 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#}
Graphics/UI/Gtk/WebKit/Types.chs view
@@ -36,7 +36,7 @@ -- module Graphics.UI.Gtk.WebKit.Types ( -  module Graphics.UI.GtkInternals,+  module Graphics.UI.Gtk.WebKit.GtkInternals,   WebView(WebView), WebViewClass,   toWebView,    mkWebView, unWebView,@@ -703,7 +703,7 @@ #endif import Foreign.C.Types    (CULong(..), CUInt(..), CULLong(..)) import System.Glib.GType  (GType, typeInstanceIsA)-{#import Graphics.UI.GtkInternals#}+import Graphics.UI.Gtk.WebKit.GtkInternals  {# context lib="gtk" prefix="gtk" #}
Graphics/UI/Gtk/WebKit/WebHistoryItem.chs view
@@ -63,7 +63,7 @@ import System.Glib.UTFString import System.Glib.GList import System.Glib.GError-import System.Glib.Attributes+import System.Glib.Attributes as G import Graphics.UI.Gtk.Gdk.Events  {#import Graphics.UI.Gtk.Abstract.Object#}	(makeNewObject)@@ -184,7 +184,7 @@ -- | The alternate title of the history item. -- -- Default value: @Nothing@-webHistoryItemAlternateTitle :: (WebHistoryItemClass self, GlibString string) => Attr self (Maybe string)+webHistoryItemAlternateTitle :: (WebHistoryItemClass self, GlibString string) => G.Attr self (Maybe string) webHistoryItemAlternateTitle = newAttr webHistoryItemGetAlternateTitle webHistoryItemSetAlternateTitle  -- | The URI of the history item.
Graphics/UI/Gtk/WebKit/WebInspector.chs view
@@ -68,7 +68,7 @@ import System.Glib.UTFString import System.Glib.GList import System.Glib.GError-import System.Glib.Attributes+import System.Glib.Attributes as G import System.Glib.Properties import Graphics.UI.Gtk.Gdk.Events @@ -144,7 +144,7 @@ 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)@@ -153,7 +153,7 @@ -- 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
Graphics/UI/Gtk/WebKit/WebSettings.chs view
@@ -102,7 +102,7 @@ import System.Glib.GList 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)@@ -143,40 +143,40 @@ -- | 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, GlibString string) => 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, GlibString string) => 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, GlibString string) => 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@@ -185,21 +185,21 @@ -- -- 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)@@ -209,58 +209,58 @@ -- 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, GlibString string) => 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.@@ -268,7 +268,7 @@ -- 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,39 +276,39 @@ -- 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, GlibString string) => 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, GlibString string) => 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, GlibString string) => Attr self string+webSettingsSerifFontFamily :: (WebSettingsClass self, GlibString string) => G.Attr self string webSettingsSerifFontFamily = newAttrFromStringProperty "serif-font-family"  @@ -321,7 +321,7 @@ -- If no value is specified then the value returned by gtk_get_default_language will be used. -- -- Default value: @Nothing@-webSettingsSpellCheckingLang :: (WebSettingsClass self, GlibString string) => 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)@@ -334,7 +334,7 @@ -- 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 @@ -347,7 +347,7 @@ -- 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@@ -360,7 +360,7 @@ -- 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 @@ -372,14 +372,14 @@ -- -- Default value: \"Mozilla/5.0 (X11; U; Linux x86_64; c) AppleWebKit/531.2+ (KHTML, like Gecko) Safari/531.2+\" -webSettingsUserAgent :: (WebSettingsClass self, GlibString string) => 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, GlibString string) => 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)@@ -406,6 +406,6 @@ -- 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
Graphics/UI/Gtk/WebKit/WebView.chs view
@@ -274,7 +274,7 @@ 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@@ -776,14 +776,14 @@  #if WEBKIT_CHECK_VERSION(1,0,1) -- | Zoom level of the 'WebView' instance-webViewZoomLevel :: WebViewClass self => Attr self Float+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 :: WebViewClass self => G.Attr self Bool webViewFullContentZoom = newAttrFromBoolProperty "full-content-zoom"  -- | The default encoding of the 'WebView' instance@@ -806,7 +806,7 @@   -- | The associated webSettings of the 'WebView' instance-webViewWebSettings :: WebViewClass self => Attr self WebSettings+webViewWebSettings :: WebViewClass self => G.Attr self WebSettings webViewWebSettings = newAttr    webViewGetWebSettings    webViewSetWebSettings@@ -824,23 +824,23 @@ -- | The custom encoding of the 'WebView' instance -- -- Default value: @Nothing@-webViewCustomEncoding :: (WebViewClass self, GlibString string) => Attr self (Maybe string)+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 :: 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 :: WebViewClass self => G.Attr self Bool webViewEditable = newAttrFromBoolProperty "editable"  -- | Returns the current URI of the contents displayed by the @web_view@.@@ -858,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#}@@ -888,7 +888,7 @@  #if WEBKIT_CHECK_VERSION(1,3,4) -- | The "view-mode" property of the 'WebView'-webViewViewMode :: (WebViewClass self) => Attr self ViewMode+webViewViewMode :: (WebViewClass self) => G.Attr self ViewMode webViewViewMode = newAttr     webViewGetViewMode     webViewSetViewMode
Graphics/UI/Gtk/WebKit/WebWindowFeatures.chs view
@@ -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"
demo/Webkit.hs view
@@ -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 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
hierarchy.list view
@@ -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
hswebkit.h view
@@ -112,3 +112,9 @@ #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+
webkit.cabal view
@@ -1,5 +1,5 @@ Name:           webkit-Version:        0.13.1.3+Version:        0.14.1.0 License:        LGPL-2.1 License-file:   COPYING Copyright:      (c) 2001-2013 The Gtk2Hs Team@@ -34,7 +34,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 @@ -48,8 +48,10 @@                         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+                        mtl,+                        transformers          build-tools:    gtk2hsC2hs >= 0.13.11,                         gtk2hsHookGenerator, gtk2hsTypeGen@@ -60,6 +62,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@@ -78,12 +81,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@@ -91,23 +97,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@@ -171,6 +169,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@@ -178,26 +178,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@@ -218,7 +230,7 @@           Graphics.UI.Gtk.WebKit.Signals          default-language:   Haskell98-        default-extensions: ForeignFunctionInterface+        default-extensions: ForeignFunctionInterface, PatternSynonyms, DeriveDataTypeable         include-dirs: .         cpp-options: -DDISABLE_DEPRECATED -U__BLOCKS__ -D__attribute__(A)= @@ -229,5 +241,4 @@          hs-source-dirs:     .         pkgconfig-depends:  webkit-1.0 >= 1.8-        build-depends:      gtk >=0.13.0.0 && <0.14         x-c2hs-Header:      hswebkit.h