diff --git a/Graphics/UI/Gtk/WebKit/DOM/ApplicationCache.chs b/Graphics/UI/Gtk/WebKit/DOM/ApplicationCache.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/ApplicationCache.chs @@ -0,0 +1,102 @@ +module Graphics.UI.Gtk.WebKit.DOM.ApplicationCache( +update, +swapCache, +abort, +pattern UNCACHED, +pattern IDLE, +pattern CHECKING, +pattern DOWNLOADING, +pattern UPDATEREADY, +pattern OBSOLETE, +getStatus, +checking, +error, +noUpdate, +downloading, +progress, +updateReady, +cached, +obsolete, +ApplicationCache, +castToApplicationCache, +gTypeApplicationCache, +ApplicationCacheClass, +toApplicationCache, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures +import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + + +update :: (MonadIO m, ApplicationCacheClass self) => self -> m () +update self + = liftIO + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_dom_application_cache_update #} + (toApplicationCache self) + errorPtr_) + +swapCache :: + (MonadIO m, ApplicationCacheClass self) => self -> m () +swapCache self + = liftIO + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_dom_application_cache_swap_cache #} + (toApplicationCache self) + errorPtr_) + +abort :: (MonadIO m, ApplicationCacheClass self) => self -> m () +abort self + = liftIO + ({# call webkit_dom_dom_application_cache_abort #} + (toApplicationCache self)) +pattern UNCACHED = 0 +pattern IDLE = 1 +pattern CHECKING = 2 +pattern DOWNLOADING = 3 +pattern UPDATEREADY = 4 +pattern OBSOLETE = 5 + +getStatus :: + (MonadIO m, ApplicationCacheClass self) => self -> m Word +getStatus self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_dom_application_cache_get_status #} + (toApplicationCache self))) + +checking :: (ApplicationCacheClass self) => EventName self Event +checking = EventName "checking" + +error :: (ApplicationCacheClass self) => EventName self UIEvent +error = EventName "error" + +noUpdate :: (ApplicationCacheClass self) => EventName self Event +noUpdate = EventName "noupdate" + +downloading :: (ApplicationCacheClass self) => EventName self Event +downloading = EventName "downloading" + +progress :: (ApplicationCacheClass self) => EventName self Event +progress = EventName "progress" + +updateReady :: (ApplicationCacheClass self) => EventName self Event +updateReady = EventName "updateready" + +cached :: (ApplicationCacheClass self) => EventName self Event +cached = EventName "cached" + +obsolete :: (ApplicationCacheClass self) => EventName self Event +obsolete = EventName "obsolete" diff --git a/Graphics/UI/Gtk/WebKit/DOM/Attr.chs b/Graphics/UI/Gtk/WebKit/DOM/Attr.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/Attr.chs @@ -0,0 +1,73 @@ +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 + + +getName :: + (MonadIO m, AttrClass self, GlibString string) => + self -> m (Maybe string) +getName self + = liftIO + (({# call webkit_dom_attr_get_name #} (toAttr self)) >>= + maybePeek readUTFString) + +getSpecified :: (MonadIO m, AttrClass self) => self -> m Bool +getSpecified self + = liftIO + (toBool <$> + ({# call webkit_dom_attr_get_specified #} (toAttr self))) + +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_) + +getValue :: + (MonadIO m, AttrClass self, GlibString string) => + self -> m (Maybe string) +getValue self + = liftIO + (({# call webkit_dom_attr_get_value #} (toAttr self)) >>= + maybePeek readUTFString) + +getOwnerElement :: + (MonadIO m, AttrClass self) => self -> m (Maybe Element) +getOwnerElement self + = liftIO + (maybeNull (makeNewGObject mkElement) + ({# call webkit_dom_attr_get_owner_element #} (toAttr self))) + +getIsId :: (MonadIO m, AttrClass self) => self -> m Bool +getIsId self + = liftIO + (toBool <$> ({# call webkit_dom_attr_get_is_id #} (toAttr self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/AudioTrack.chs b/Graphics/UI/Gtk/WebKit/DOM/AudioTrack.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/AudioTrack.chs @@ -0,0 +1,60 @@ +module Graphics.UI.Gtk.WebKit.DOM.AudioTrack( +#if WEBKIT_CHECK_VERSION(2,2,2) +getId, +getLabel, +setEnabled, +getEnabled, +AudioTrack, +castToAudioTrack, +gTypeAudioTrack, +AudioTrackClass, +toAudioTrack, +#endif +) where +#if WEBKIT_CHECK_VERSION(2,2,2) +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures +import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + + +getId :: + (MonadIO m, AudioTrackClass self, GlibString string) => + self -> m string +getId self + = liftIO + (({# call webkit_dom_audio_track_get_id #} (toAudioTrack self)) >>= + readUTFString) + +getLabel :: + (MonadIO m, AudioTrackClass self, GlibString string) => + self -> m string +getLabel self + = liftIO + (({# call webkit_dom_audio_track_get_label #} (toAudioTrack self)) + >>= + readUTFString) + +setEnabled :: + (MonadIO m, AudioTrackClass self) => self -> Bool -> m () +setEnabled self val + = liftIO + ({# call webkit_dom_audio_track_set_enabled #} (toAudioTrack self) + (fromBool val)) + +getEnabled :: (MonadIO m, AudioTrackClass self) => self -> m Bool +getEnabled self + = liftIO + (toBool <$> + ({# call webkit_dom_audio_track_get_enabled #} + (toAudioTrack self))) +#endif diff --git a/Graphics/UI/Gtk/WebKit/DOM/AudioTrackList.chs b/Graphics/UI/Gtk/WebKit/DOM/AudioTrackList.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/AudioTrackList.chs @@ -0,0 +1,70 @@ +module Graphics.UI.Gtk.WebKit.DOM.AudioTrackList( +#if WEBKIT_CHECK_VERSION(2,2,2) +item, +getTrackById, +getLength, +change, +addTrack, +removeTrack, +AudioTrackList, +castToAudioTrackList, +gTypeAudioTrackList, +AudioTrackListClass, +toAudioTrackList, +#endif +) where +#if WEBKIT_CHECK_VERSION(2,2,2) +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures +import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + + +item :: + (MonadIO m, AudioTrackListClass self) => + self -> Word -> m (Maybe AudioTrack) +item self index + = liftIO + (maybeNull (makeNewGObject mkAudioTrack) + ({# call webkit_dom_audio_track_list_item #} + (toAudioTrackList self) + (fromIntegral index))) + +getTrackById :: + (MonadIO m, AudioTrackListClass self, GlibString string) => + self -> string -> m (Maybe AudioTrack) +getTrackById self id + = liftIO + (maybeNull (makeNewGObject mkAudioTrack) + (withUTFString id $ + \ idPtr -> + {# call webkit_dom_audio_track_list_get_track_by_id #} + (toAudioTrackList self) + idPtr)) + +getLength :: + (MonadIO m, AudioTrackListClass self) => self -> m Word +getLength self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_audio_track_list_get_length #} + (toAudioTrackList self))) + +change :: (AudioTrackListClass self) => EventName self Event +change = EventName "change" + +addTrack :: (AudioTrackListClass self) => EventName self Event +addTrack = EventName "addtrack" + +removeTrack :: (AudioTrackListClass self) => EventName self Event +removeTrack = EventName "removetrack" +#endif diff --git a/Graphics/UI/Gtk/WebKit/DOM/BarProp.chs b/Graphics/UI/Gtk/WebKit/DOM/BarProp.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/BarProp.chs @@ -0,0 +1,32 @@ +module Graphics.UI.Gtk.WebKit.DOM.BarProp( +#if WEBKIT_CHECK_VERSION(2,2,2) +getVisible, +BarProp, +castToBarProp, +gTypeBarProp, +BarPropClass, +toBarProp, +#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 + + +getVisible :: (MonadIO m, BarPropClass self) => self -> m Bool +getVisible self + = liftIO + (toBool <$> + ({# call webkit_dom_bar_prop_get_visible #} (toBarProp self))) +#endif diff --git a/Graphics/UI/Gtk/WebKit/DOM/BatteryManager.chs b/Graphics/UI/Gtk/WebKit/DOM/BatteryManager.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/BatteryManager.chs @@ -0,0 +1,80 @@ +module Graphics.UI.Gtk.WebKit.DOM.BatteryManager( +#if WEBKIT_CHECK_VERSION(2,2,2) +getCharging, +getChargingTime, +getDischargingTime, +getLevel, +chargingChange, +chargingTimeChange, +dischargingTimeChange, +levelChange, +BatteryManager, +castToBatteryManager, +gTypeBatteryManager, +BatteryManagerClass, +toBatteryManager, +#endif +) where +#if WEBKIT_CHECK_VERSION(2,2,2) +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures +import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + + +getCharging :: + (MonadIO m, BatteryManagerClass self) => self -> m Bool +getCharging self + = liftIO + (toBool <$> + ({# call webkit_dom_battery_manager_get_charging #} + (toBatteryManager self))) + +getChargingTime :: + (MonadIO m, BatteryManagerClass self) => self -> m Double +getChargingTime self + = liftIO + (realToFrac <$> + ({# call webkit_dom_battery_manager_get_charging_time #} + (toBatteryManager self))) + +getDischargingTime :: + (MonadIO m, BatteryManagerClass self) => self -> m Double +getDischargingTime self + = liftIO + (realToFrac <$> + ({# call webkit_dom_battery_manager_get_discharging_time #} + (toBatteryManager self))) + +getLevel :: + (MonadIO m, BatteryManagerClass self) => self -> m Double +getLevel self + = liftIO + (realToFrac <$> + ({# call webkit_dom_battery_manager_get_level #} + (toBatteryManager self))) + +chargingChange :: + (BatteryManagerClass self) => EventName self Event +chargingChange = EventName "chargingchange" + +chargingTimeChange :: + (BatteryManagerClass self) => EventName self Event +chargingTimeChange = EventName "chargingtimechange" + +dischargingTimeChange :: + (BatteryManagerClass self) => EventName self Event +dischargingTimeChange = EventName "dischargingtimechange" + +levelChange :: (BatteryManagerClass self) => EventName self Event +levelChange = EventName "levelchange" +#endif diff --git a/Graphics/UI/Gtk/WebKit/DOM/Blob.chs b/Graphics/UI/Gtk/WebKit/DOM/Blob.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/Blob.chs @@ -0,0 +1,41 @@ +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 + + +slice :: + (MonadIO m, BlobClass self, GlibString string) => + self -> Int64 -> Int64 -> (Maybe string) -> m (Maybe Blob) +slice self start end contentType + = liftIO + (maybeNull (makeNewGObject mkBlob) + (maybeWith withUTFString contentType $ + \ contentTypePtr -> + {# call webkit_dom_blob_slice #} (toBlob self) (fromIntegral start) + (fromIntegral end) + contentTypePtr)) + +getSize :: (MonadIO m, BlobClass self) => self -> m Word64 +getSize self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_blob_get_size #} (toBlob self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/CSS.chs b/Graphics/UI/Gtk/WebKit/DOM/CSS.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/CSS.chs @@ -0,0 +1,40 @@ +module Graphics.UI.Gtk.WebKit.DOM.CSS( +#if WEBKIT_CHECK_VERSION(2,2,2) +supports2, +CSS, +castToCSS, +gTypeCSS, +CSSClass, +toCSS, +#endif +) where +#if WEBKIT_CHECK_VERSION(2,2,2) +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures +import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + + +supports2 :: + (MonadIO m, CSSClass self, GlibString string) => + self -> string -> string -> m Bool +supports2 self property value + = liftIO + (toBool <$> + (withUTFString value $ + \ valuePtr -> + withUTFString property $ + \ propertyPtr -> + {# call webkit_dom_dom_window_css_supports #} (toCSS self) + propertyPtr + valuePtr)) +#endif diff --git a/Graphics/UI/Gtk/WebKit/DOM/CSSRule.chs b/Graphics/UI/Gtk/WebKit/DOM/CSSRule.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/CSSRule.chs @@ -0,0 +1,88 @@ +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 +{#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 + +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_) + +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) + +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))) + +getParentRule :: + (MonadIO m, CSSRuleClass self) => self -> m (Maybe CSSRule) +getParentRule self + = liftIO + (maybeNull (makeNewGObject mkCSSRule) + ({# call webkit_dom_css_rule_get_parent_rule #} (toCSSRule self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/CSSRuleList.chs b/Graphics/UI/Gtk/WebKit/DOM/CSSRuleList.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/CSSRuleList.chs @@ -0,0 +1,39 @@ +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 + + +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))) + +getLength :: (MonadIO m, CSSRuleListClass self) => self -> m Word +getLength self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_css_rule_list_get_length #} + (toCSSRuleList self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/CSSStyleDeclaration.chs b/Graphics/UI/Gtk/WebKit/DOM/CSSStyleDeclaration.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/CSSStyleDeclaration.chs @@ -0,0 +1,171 @@ +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 + + +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) + +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) + +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) + +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_) + +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) + +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) + +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)) + +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_) + +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) + +getLength :: + (MonadIO m, CSSStyleDeclarationClass self) => self -> m Word +getLength self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_css_style_declaration_get_length #} + (toCSSStyleDeclaration self))) + +getParentRule :: + (MonadIO m, CSSStyleDeclarationClass self) => + self -> m (Maybe CSSRule) +getParentRule self + = liftIO + (maybeNull (makeNewGObject mkCSSRule) + ({# call webkit_dom_css_style_declaration_get_parent_rule #} + (toCSSStyleDeclaration self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/CSSStyleSheet.chs b/Graphics/UI/Gtk/WebKit/DOM/CSSStyleSheet.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/CSSStyleSheet.chs @@ -0,0 +1,111 @@ +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 + + +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_ -> + {# 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_)) + +removeRule :: + (MonadIO m, CSSStyleSheetClass self) => self -> Word -> m () +removeRule self index + = liftIO + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_css_style_sheet_remove_rule #} + (toCSSStyleSheet self) + (fromIntegral index) + errorPtr_) + +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))) + +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))) + +getRules :: + (MonadIO m, CSSStyleSheetClass self) => + self -> m (Maybe CSSRuleList) +getRules self + = liftIO + (maybeNull (makeNewGObject mkCSSRuleList) + ({# call webkit_dom_css_style_sheet_get_rules #} + (toCSSStyleSheet self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/CSSValue.chs b/Graphics/UI/Gtk/WebKit/DOM/CSSValue.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/CSSValue.chs @@ -0,0 +1,62 @@ +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 +{#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 + +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_) + +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) + +getCssValueType :: + (MonadIO m, CSSValueClass self) => self -> m Word +getCssValueType self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_css_value_get_css_value_type #} + (toCSSValue self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/CharacterData.chs b/Graphics/UI/Gtk/WebKit/DOM/CharacterData.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/CharacterData.chs @@ -0,0 +1,133 @@ +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 +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + + +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) + (fromIntegral length) + errorPtr_) + >>= + maybePeek readUTFString) + +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_) + +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_) + +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_) + +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_) + +setData :: + (MonadIO m, CharacterDataClass self, GlibString string) => + self -> (Maybe string) -> m () +setData self val + = liftIO + (propagateGError $ + \ errorPtr_ -> + maybeWith withUTFString val $ + \ valPtr -> + {# call webkit_dom_character_data_set_data #} + (toCharacterData self) + valPtr + errorPtr_) + +getData :: + (MonadIO m, CharacterDataClass self, GlibString string) => + self -> m (Maybe string) +getData self + = liftIO + (({# call webkit_dom_character_data_get_data #} + (toCharacterData self)) + >>= + maybePeek readUTFString) + +getLength :: (MonadIO m, CharacterDataClass self) => self -> m Word +getLength self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_character_data_get_length #} + (toCharacterData self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/DOMImplementation.chs b/Graphics/UI/Gtk/WebKit/DOM/DOMImplementation.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/DOMImplementation.chs @@ -0,0 +1,116 @@ +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 + + +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)) + +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_)) + +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_)) + +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_)) + +createHTMLDocument :: + (MonadIO m, DOMImplementationClass self, GlibString string) => + self -> string -> m (Maybe HTMLDocument) +createHTMLDocument self title + = liftIO + (maybeNull (makeNewGObject mkHTMLDocument) + (withUTFString title $ + \ titlePtr -> + {# call webkit_dom_dom_implementation_create_html_document #} + (toDOMImplementation self) + titlePtr)) diff --git a/Graphics/UI/Gtk/WebKit/DOM/DOMNamedFlowCollection.chs b/Graphics/UI/Gtk/WebKit/DOM/DOMNamedFlowCollection.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/DOMNamedFlowCollection.chs @@ -0,0 +1,58 @@ +module Graphics.UI.Gtk.WebKit.DOM.DOMNamedFlowCollection( +#if WEBKIT_CHECK_VERSION(2,2,2) +item, +namedItem, +getLength, +DOMNamedFlowCollection, +castToDOMNamedFlowCollection, +gTypeDOMNamedFlowCollection, +DOMNamedFlowCollectionClass, +toDOMNamedFlowCollection, +#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, 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))) + +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)) + +getLength :: + (MonadIO m, DOMNamedFlowCollectionClass self) => self -> m Word +getLength self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_dom_named_flow_collection_get_length #} + (toDOMNamedFlowCollection self))) +#endif diff --git a/Graphics/UI/Gtk/WebKit/DOM/DOMSettableTokenList.chs b/Graphics/UI/Gtk/WebKit/DOM/DOMSettableTokenList.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/DOMSettableTokenList.chs @@ -0,0 +1,44 @@ +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 + + +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) + +getValue :: + (MonadIO m, DOMSettableTokenListClass self, GlibString string) => + self -> m string +getValue self + = liftIO + (({# call webkit_dom_dom_settable_token_list_get_value #} + (toDOMSettableTokenList self)) + >>= + readUTFString) diff --git a/Graphics/UI/Gtk/WebKit/DOM/DOMStringList.chs b/Graphics/UI/Gtk/WebKit/DOM/DOMStringList.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/DOMStringList.chs @@ -0,0 +1,53 @@ +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 + + +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) + +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)) + +getLength :: (MonadIO m, DOMStringListClass self) => self -> m Word +getLength self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_dom_string_list_get_length #} + (toDOMStringList self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/DOMTokenList.chs b/Graphics/UI/Gtk/WebKit/DOM/DOMTokenList.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/DOMTokenList.chs @@ -0,0 +1,103 @@ +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 +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + + +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 tokens $ + \ tokensPtr -> + {# call webkit_dom_dom_token_list_add #} (toDOMTokenList self) + tokensPtr + errorPtr_) + +remove :: + (MonadIO m, DOMTokenListClass self, GlibString string) => + self -> string -> m () +remove self tokens + = liftIO + (propagateGError $ + \ errorPtr_ -> + withUTFString tokens $ + \ tokensPtr -> + {# call webkit_dom_dom_token_list_remove #} (toDOMTokenList self) + tokensPtr + errorPtr_) + +#if WEBKIT_CHECK_VERSION(2,2,2) +toggle :: + (MonadIO m, DOMTokenListClass self, GlibString string) => + self -> string -> Bool -> m Bool +toggle self token force + = liftIO + (toBool <$> + (propagateGError $ + \ errorPtr_ -> + withUTFString token $ + \ tokenPtr -> + {# call webkit_dom_dom_token_list_toggle #} (toDOMTokenList self) + tokenPtr + (fromBool force) + errorPtr_)) +#endif + +getLength :: (MonadIO m, DOMTokenListClass self) => self -> m Word +getLength self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_dom_token_list_get_length #} + (toDOMTokenList self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/Document.chs b/Graphics/UI/Gtk/WebKit/DOM/Document.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/Document.chs @@ -0,0 +1,1326 @@ +module Graphics.UI.Gtk.WebKit.DOM.Document( +createElement, +createDocumentFragment, +createTextNode, +createComment, +createCDATASection, +createProcessingInstruction, +createAttribute, +createEntityReference, +getElementsByTagName, +importNode, +createElementNS, +createAttributeNS, +getElementsByTagNameNS, +getElementById, +adoptNode, +createEvent, +createRange, +createNodeIterator, +createTreeWalker, +getOverrideStyle, +createExpression, +createNSResolver, +evaluate, +execCommand, +queryCommandEnabled, +queryCommandIndeterm, +queryCommandState, +queryCommandSupported, +queryCommandValue, +getElementsByName, +elementFromPoint, +caretRangeFromPoint, +createCSSStyleDeclaration, +getElementsByClassName, +#if WEBKIT_CHECK_VERSION(2,5,1) +hasFocus, +#endif +querySelector, +querySelectorAll, +webkitCancelFullScreen, +#if WEBKIT_CHECK_VERSION(2,2,2) +webkitExitFullscreen, +webkitGetNamedFlows, +#endif +#if WEBKIT_CHECK_VERSION(2,4,2) +createTouch, +#endif +getDoctype, +getImplementation, +getDocumentElement, +getInputEncoding, +getXmlEncoding, +setXmlVersion, +getXmlVersion, +setXmlStandalone, +getXmlStandalone, +getDocumentURI, +getDefaultView, +getStyleSheets, +setTitle, +getTitle, +getReferrer, +getDomain, +setCookie, +getCookie, +setBody, +getBody, +getHead, +getImages, +getApplets, +getLinks, +getForms, +getAnchors, +getLastModified, +setCharset, +getCharset, +getDefaultCharset, +getReadyState, +getCharacterSet, +getPreferredStylesheetSet, +setSelectedStylesheetSet, +getSelectedStylesheetSet, +getCompatMode, +getWebkitIsFullScreen, +getWebkitFullScreenKeyboardInputAllowed, +getWebkitCurrentFullScreenElement, +#if WEBKIT_CHECK_VERSION(2,2,2) +getWebkitFullscreenEnabled, +getWebkitFullscreenElement, +#endif +abort, +blur, +change, +click, +contextMenu, +dblClick, +drag, +dragEnd, +dragEnter, +dragLeave, +dragOver, +dragStart, +drop, +error, +focus, +input, +invalid, +#if WEBKIT_CHECK_VERSION(2,2,2) +keyDown, +keyPress, +keyUp, +#endif +load, +mouseDown, +mouseEnter, +mouseLeave, +mouseMove, +mouseOut, +mouseOver, +mouseUp, +mouseWheel, +readyStateChange, +scroll, +select, +submit, +#if WEBKIT_CHECK_VERSION(2,4,0) +wheel, +#endif +beforeCut, +cut, +beforeCopy, +copy, +beforePaste, +paste, +reset, +search, +selectStart, +selectionchange, +touchStart, +touchMove, +touchEnd, +touchCancel, +webKitFullscreenChange, +webKitFullscreenError, +pointerlockchange, +pointerlockerror, +securitypolicyviolation, +webKitWillRevealBottom, +webKitWillRevealLeft, +webKitWillRevealRight, +webKitWillRevealTop, +getVisibilityState, +getHidden, +#if WEBKIT_CHECK_VERSION(1,10,0) +getSecurityPolicy, +#endif +#if WEBKIT_CHECK_VERSION(2,2,2) +getCurrentScript, +#endif +Document, +castToDocument, +gTypeDocument, +DocumentClass, +toDocument, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures +import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + + +createElement :: + (MonadIO m, DocumentClass self, GlibString string) => + self -> (Maybe string) -> m (Maybe Element) +createElement self tagName + = liftIO + (maybeNull (makeNewGObject mkElement) + (propagateGError $ + \ errorPtr_ -> + maybeWith withUTFString tagName $ + \ tagNamePtr -> + {# call webkit_dom_document_create_element #} (toDocument self) + tagNamePtr + errorPtr_)) + +createDocumentFragment :: + (MonadIO m, DocumentClass self) => + self -> m (Maybe DocumentFragment) +createDocumentFragment self + = liftIO + (maybeNull (makeNewGObject mkDocumentFragment) + ({# call webkit_dom_document_create_document_fragment #} + (toDocument self))) + +createTextNode :: + (MonadIO m, DocumentClass self, GlibString string) => + self -> string -> m (Maybe Text) +createTextNode self data' + = liftIO + (maybeNull (makeNewGObject mkText) + (withUTFString data' $ + \ dataPtr -> + {# call webkit_dom_document_create_text_node #} (toDocument self) + dataPtr)) + +createComment :: + (MonadIO m, DocumentClass self, GlibString string) => + self -> string -> m (Maybe Comment) +createComment self data' + = liftIO + (maybeNull (makeNewGObject mkComment) + (withUTFString data' $ + \ dataPtr -> + {# call webkit_dom_document_create_comment #} (toDocument self) + dataPtr)) + +createCDATASection :: + (MonadIO m, DocumentClass self, GlibString string) => + self -> string -> m (Maybe CDATASection) +createCDATASection self data' + = liftIO + (maybeNull (makeNewGObject mkCDATASection) + (propagateGError $ + \ errorPtr_ -> + withUTFString data' $ + \ dataPtr -> + {# call webkit_dom_document_create_cdata_section #} + (toDocument self) + dataPtr + errorPtr_)) + +createProcessingInstruction :: + (MonadIO m, DocumentClass self, GlibString string) => + self -> string -> string -> m (Maybe ProcessingInstruction) +createProcessingInstruction self target data' + = liftIO + (maybeNull (makeNewGObject mkProcessingInstruction) + (propagateGError $ + \ errorPtr_ -> + withUTFString data' $ + \ dataPtr -> + withUTFString target $ + \ targetPtr -> + {# call webkit_dom_document_create_processing_instruction #} + (toDocument self) + targetPtr + dataPtr + errorPtr_)) + +createAttribute :: + (MonadIO m, DocumentClass self, GlibString string) => + self -> string -> m (Maybe Attr) +createAttribute self name + = liftIO + (maybeNull (makeNewGObject mkAttr) + (propagateGError $ + \ errorPtr_ -> + withUTFString name $ + \ namePtr -> + {# call webkit_dom_document_create_attribute #} (toDocument self) + namePtr + errorPtr_)) + +createEntityReference :: + (MonadIO m, DocumentClass self, GlibString string) => + self -> string -> m (Maybe EntityReference) +createEntityReference self name + = liftIO + (maybeNull (makeNewGObject mkEntityReference) + (propagateGError $ + \ errorPtr_ -> + withUTFString name $ + \ namePtr -> + {# call webkit_dom_document_create_entity_reference #} + (toDocument self) + namePtr + errorPtr_)) + +getElementsByTagName :: + (MonadIO m, DocumentClass self, GlibString string) => + self -> string -> m (Maybe NodeList) +getElementsByTagName self tagname + = liftIO + (maybeNull (makeNewGObject mkNodeList) + (withUTFString tagname $ + \ tagnamePtr -> + {# call webkit_dom_document_get_elements_by_tag_name #} + (toDocument self) + tagnamePtr)) + +importNode :: + (MonadIO m, DocumentClass self, NodeClass importedNode) => + self -> Maybe importedNode -> Bool -> m (Maybe Node) +importNode self importedNode deep + = liftIO + (maybeNull (makeNewGObject mkNode) + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_document_import_node #} (toDocument self) + (maybe (Node nullForeignPtr) toNode importedNode) + (fromBool deep) + errorPtr_)) + +createElementNS :: + (MonadIO m, DocumentClass self, GlibString string) => + self -> (Maybe string) -> (Maybe string) -> m (Maybe Element) +createElementNS self namespaceURI qualifiedName + = liftIO + (maybeNull (makeNewGObject mkElement) + (propagateGError $ + \ errorPtr_ -> + maybeWith withUTFString qualifiedName $ + \ qualifiedNamePtr -> + maybeWith withUTFString namespaceURI $ + \ namespaceURIPtr -> + {# call webkit_dom_document_create_element_ns #} (toDocument self) + namespaceURIPtr + qualifiedNamePtr + errorPtr_)) + +createAttributeNS :: + (MonadIO m, DocumentClass self, GlibString string) => + self -> (Maybe string) -> (Maybe string) -> m (Maybe Attr) +createAttributeNS self namespaceURI qualifiedName + = liftIO + (maybeNull (makeNewGObject mkAttr) + (propagateGError $ + \ errorPtr_ -> + maybeWith withUTFString qualifiedName $ + \ qualifiedNamePtr -> + maybeWith withUTFString namespaceURI $ + \ namespaceURIPtr -> + {# call webkit_dom_document_create_attribute_ns #} + (toDocument self) + namespaceURIPtr + qualifiedNamePtr + errorPtr_)) + +getElementsByTagNameNS :: + (MonadIO m, DocumentClass self, GlibString string) => + self -> (Maybe string) -> string -> m (Maybe NodeList) +getElementsByTagNameNS self namespaceURI localName + = liftIO + (maybeNull (makeNewGObject mkNodeList) + (withUTFString localName $ + \ localNamePtr -> + maybeWith withUTFString namespaceURI $ + \ namespaceURIPtr -> + {# call webkit_dom_document_get_elements_by_tag_name_ns #} + (toDocument self) + namespaceURIPtr + localNamePtr)) + +getElementById :: + (MonadIO m, DocumentClass self, GlibString string) => + self -> string -> m (Maybe Element) +getElementById self elementId + = liftIO + (maybeNull (makeNewGObject mkElement) + (withUTFString elementId $ + \ elementIdPtr -> + {# call webkit_dom_document_get_element_by_id #} (toDocument self) + elementIdPtr)) + +adoptNode :: + (MonadIO m, DocumentClass self, NodeClass source) => + self -> Maybe source -> m (Maybe Node) +adoptNode self source + = liftIO + (maybeNull (makeNewGObject mkNode) + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_document_adopt_node #} (toDocument self) + (maybe (Node nullForeignPtr) toNode source) + errorPtr_)) + +createEvent :: + (MonadIO m, DocumentClass self, GlibString string) => + self -> string -> m (Maybe Event) +createEvent self eventType + = liftIO + (maybeNull (makeNewGObject mkEvent) + (propagateGError $ + \ errorPtr_ -> + withUTFString eventType $ + \ eventTypePtr -> + {# call webkit_dom_document_create_event #} (toDocument self) + eventTypePtr + errorPtr_)) + +createRange :: + (MonadIO m, DocumentClass self) => self -> m (Maybe Range) +createRange self + = liftIO + (maybeNull (makeNewGObject mkRange) + ({# call webkit_dom_document_create_range #} (toDocument self))) + +createNodeIterator :: + (MonadIO m, DocumentClass self, NodeClass root, + NodeFilterClass filter) => + self -> + Maybe root -> + Word -> Maybe filter -> Bool -> m (Maybe NodeIterator) +createNodeIterator self root whatToShow filter + expandEntityReferences + = liftIO + (maybeNull (makeNewGObject mkNodeIterator) + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_document_create_node_iterator #} + (toDocument self) + (maybe (Node nullForeignPtr) toNode root) + (fromIntegral whatToShow) + (maybe (NodeFilter nullForeignPtr) toNodeFilter filter) + (fromBool expandEntityReferences) + errorPtr_)) + +createTreeWalker :: + (MonadIO m, DocumentClass self, NodeClass root, + NodeFilterClass filter) => + self -> + Maybe root -> Word -> Maybe filter -> Bool -> m (Maybe TreeWalker) +createTreeWalker self root whatToShow filter expandEntityReferences + = liftIO + (maybeNull (makeNewGObject mkTreeWalker) + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_document_create_tree_walker #} (toDocument self) + (maybe (Node nullForeignPtr) toNode root) + (fromIntegral whatToShow) + (maybe (NodeFilter nullForeignPtr) toNodeFilter filter) + (fromBool expandEntityReferences) + errorPtr_)) + +getOverrideStyle :: + (MonadIO m, DocumentClass self, ElementClass element, + GlibString string) => + self -> Maybe element -> string -> m (Maybe CSSStyleDeclaration) +getOverrideStyle self element pseudoElement + = liftIO + (maybeNull (makeNewGObject mkCSSStyleDeclaration) + (withUTFString pseudoElement $ + \ pseudoElementPtr -> + {# call webkit_dom_document_get_override_style #} (toDocument self) + (maybe (Element nullForeignPtr) toElement element) + pseudoElementPtr)) + +createExpression :: + (MonadIO m, DocumentClass self, XPathNSResolverClass resolver, + GlibString string) => + self -> string -> Maybe resolver -> m (Maybe XPathExpression) +createExpression self expression resolver + = liftIO + (maybeNull (makeNewGObject mkXPathExpression) + (propagateGError $ + \ errorPtr_ -> + withUTFString expression $ + \ expressionPtr -> + {# call webkit_dom_document_create_expression #} (toDocument self) + expressionPtr + (maybe (XPathNSResolver nullForeignPtr) toXPathNSResolver resolver) + errorPtr_)) + +createNSResolver :: + (MonadIO m, DocumentClass self, NodeClass nodeResolver) => + self -> Maybe nodeResolver -> m (Maybe XPathNSResolver) +createNSResolver self nodeResolver + = liftIO + (maybeNull (makeNewGObject mkXPathNSResolver) + ({# call webkit_dom_document_create_ns_resolver #} + (toDocument self) + (maybe (Node nullForeignPtr) toNode nodeResolver))) + +evaluate :: + (MonadIO m, DocumentClass self, NodeClass contextNode, + XPathNSResolverClass resolver, XPathResultClass inResult, + GlibString string) => + self -> + string -> + Maybe contextNode -> + Maybe resolver -> Word -> Maybe inResult -> m (Maybe XPathResult) +evaluate self expression contextNode resolver type' inResult + = liftIO + (maybeNull (makeNewGObject mkXPathResult) + (propagateGError $ + \ errorPtr_ -> + withUTFString expression $ + \ expressionPtr -> + {# call webkit_dom_document_evaluate #} (toDocument self) + expressionPtr + (maybe (Node nullForeignPtr) toNode contextNode) + (maybe (XPathNSResolver nullForeignPtr) toXPathNSResolver resolver) + (fromIntegral type') + (maybe (XPathResult nullForeignPtr) toXPathResult inResult) + errorPtr_)) + +execCommand :: + (MonadIO m, DocumentClass self, GlibString string) => + self -> string -> Bool -> (Maybe string) -> m Bool +execCommand self command userInterface value + = liftIO + (toBool <$> + (maybeWith withUTFString value $ + \ valuePtr -> + withUTFString command $ + \ commandPtr -> + {# call webkit_dom_document_exec_command #} (toDocument self) + commandPtr + (fromBool userInterface) + valuePtr)) + +queryCommandEnabled :: + (MonadIO m, DocumentClass self, GlibString string) => + self -> string -> m Bool +queryCommandEnabled self command + = liftIO + (toBool <$> + (withUTFString command $ + \ commandPtr -> + {# call webkit_dom_document_query_command_enabled #} + (toDocument self) + commandPtr)) + +queryCommandIndeterm :: + (MonadIO m, DocumentClass self, GlibString string) => + self -> string -> m Bool +queryCommandIndeterm self command + = liftIO + (toBool <$> + (withUTFString command $ + \ commandPtr -> + {# call webkit_dom_document_query_command_indeterm #} + (toDocument self) + commandPtr)) + +queryCommandState :: + (MonadIO m, DocumentClass self, GlibString string) => + self -> string -> m Bool +queryCommandState self command + = liftIO + (toBool <$> + (withUTFString command $ + \ commandPtr -> + {# call webkit_dom_document_query_command_state #} + (toDocument self) + commandPtr)) + +queryCommandSupported :: + (MonadIO m, DocumentClass self, GlibString string) => + self -> string -> m Bool +queryCommandSupported self command + = liftIO + (toBool <$> + (withUTFString command $ + \ commandPtr -> + {# call webkit_dom_document_query_command_supported #} + (toDocument self) + commandPtr)) + +queryCommandValue :: + (MonadIO m, DocumentClass self, GlibString string) => + self -> string -> m string +queryCommandValue self command + = liftIO + ((withUTFString command $ + \ commandPtr -> + {# call webkit_dom_document_query_command_value #} + (toDocument self) + commandPtr) + >>= + readUTFString) + +getElementsByName :: + (MonadIO m, DocumentClass self, GlibString string) => + self -> string -> m (Maybe NodeList) +getElementsByName self elementName + = liftIO + (maybeNull (makeNewGObject mkNodeList) + (withUTFString elementName $ + \ elementNamePtr -> + {# call webkit_dom_document_get_elements_by_name #} + (toDocument self) + elementNamePtr)) + +elementFromPoint :: + (MonadIO m, DocumentClass self) => + self -> Int -> Int -> m (Maybe Element) +elementFromPoint self x y + = liftIO + (maybeNull (makeNewGObject mkElement) + ({# call webkit_dom_document_element_from_point #} + (toDocument self) + (fromIntegral x) + (fromIntegral y))) + +caretRangeFromPoint :: + (MonadIO m, DocumentClass self) => + self -> Int -> Int -> m (Maybe Range) +caretRangeFromPoint self x y + = liftIO + (maybeNull (makeNewGObject mkRange) + ({# call webkit_dom_document_caret_range_from_point #} + (toDocument self) + (fromIntegral x) + (fromIntegral y))) + +createCSSStyleDeclaration :: + (MonadIO m, DocumentClass self) => + self -> m (Maybe CSSStyleDeclaration) +createCSSStyleDeclaration self + = liftIO + (maybeNull (makeNewGObject mkCSSStyleDeclaration) + ({# call webkit_dom_document_create_css_style_declaration #} + (toDocument self))) + +getElementsByClassName :: + (MonadIO m, DocumentClass self, GlibString string) => + self -> string -> m (Maybe NodeList) +getElementsByClassName self tagname + = liftIO + (maybeNull (makeNewGObject mkNodeList) + (withUTFString tagname $ + \ tagnamePtr -> + {# call webkit_dom_document_get_elements_by_class_name #} + (toDocument self) + tagnamePtr)) + +#if WEBKIT_CHECK_VERSION(2,5,1) +hasFocus :: (MonadIO m, DocumentClass self) => self -> m Bool +hasFocus self + = liftIO + (toBool <$> + ({# call webkit_dom_document_has_focus #} (toDocument self))) +#endif + +querySelector :: + (MonadIO m, DocumentClass self, GlibString string) => + self -> string -> m (Maybe Element) +querySelector self selectors + = liftIO + (maybeNull (makeNewGObject mkElement) + (propagateGError $ + \ errorPtr_ -> + withUTFString selectors $ + \ selectorsPtr -> + {# call webkit_dom_document_query_selector #} (toDocument self) + selectorsPtr + errorPtr_)) + +querySelectorAll :: + (MonadIO m, DocumentClass self, GlibString string) => + self -> string -> m (Maybe NodeList) +querySelectorAll self selectors + = liftIO + (maybeNull (makeNewGObject mkNodeList) + (propagateGError $ + \ errorPtr_ -> + withUTFString selectors $ + \ selectorsPtr -> + {# call webkit_dom_document_query_selector_all #} (toDocument self) + selectorsPtr + errorPtr_)) + +webkitCancelFullScreen :: + (MonadIO m, DocumentClass self) => self -> m () +webkitCancelFullScreen self + = liftIO + ({# call webkit_dom_document_webkit_cancel_full_screen #} + (toDocument self)) + +#if WEBKIT_CHECK_VERSION(2,2,2) +webkitExitFullscreen :: + (MonadIO m, DocumentClass self) => self -> m () +webkitExitFullscreen self + = liftIO + ({# call webkit_dom_document_webkit_exit_fullscreen #} + (toDocument self)) + +webkitGetNamedFlows :: + (MonadIO m, DocumentClass self) => + self -> m (Maybe DOMNamedFlowCollection) +webkitGetNamedFlows self + = liftIO + (maybeNull (makeNewGObject mkDOMNamedFlowCollection) + ({# call webkit_dom_document_webkit_get_named_flows #} + (toDocument self))) +#endif + +#if WEBKIT_CHECK_VERSION(2,4,2) +createTouch :: + (MonadIO m, DocumentClass self, WindowClass window, + EventTargetClass target) => + self -> + Maybe window -> + Maybe target -> + Int -> + Int -> + Int -> + Int -> Int -> Int -> Int -> Float -> Float -> m (Maybe Touch) +createTouch self window target identifier pageX pageY screenX + screenY webkitRadiusX webkitRadiusY webkitRotationAngle webkitForce + = liftIO + (maybeNull (makeNewGObject mkTouch) + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_document_create_touch #} (toDocument self) + (maybe (Window nullForeignPtr) toWindow window) + (maybe (EventTarget nullForeignPtr) toEventTarget target) + (fromIntegral identifier) + (fromIntegral pageX) + (fromIntegral pageY) + (fromIntegral screenX) + (fromIntegral screenY) + (fromIntegral webkitRadiusX) + (fromIntegral webkitRadiusY) + (realToFrac webkitRotationAngle) + (realToFrac webkitForce) + errorPtr_)) +#endif + +getDoctype :: + (MonadIO m, DocumentClass self) => self -> m (Maybe DocumentType) +getDoctype self + = liftIO + (maybeNull (makeNewGObject mkDocumentType) + ({# call webkit_dom_document_get_doctype #} (toDocument self))) + +getImplementation :: + (MonadIO m, DocumentClass self) => + self -> m (Maybe DOMImplementation) +getImplementation self + = liftIO + (maybeNull (makeNewGObject mkDOMImplementation) + ({# call webkit_dom_document_get_implementation #} + (toDocument self))) + +getDocumentElement :: + (MonadIO m, DocumentClass self) => self -> m (Maybe Element) +getDocumentElement self + = liftIO + (maybeNull (makeNewGObject mkElement) + ({# call webkit_dom_document_get_document_element #} + (toDocument self))) + +getInputEncoding :: + (MonadIO m, DocumentClass self, GlibString string) => + self -> m (Maybe string) +getInputEncoding self + = liftIO + (({# call webkit_dom_document_get_input_encoding #} + (toDocument self)) + >>= + maybePeek readUTFString) + +getXmlEncoding :: + (MonadIO m, DocumentClass self, GlibString string) => + self -> m (Maybe string) +getXmlEncoding self + = liftIO + (({# call webkit_dom_document_get_xml_encoding #} + (toDocument self)) + >>= + maybePeek readUTFString) + +setXmlVersion :: + (MonadIO m, DocumentClass self, GlibString string) => + self -> (Maybe string) -> m () +setXmlVersion self val + = liftIO + (propagateGError $ + \ errorPtr_ -> + maybeWith withUTFString val $ + \ valPtr -> + {# call webkit_dom_document_set_xml_version #} (toDocument self) + valPtr + errorPtr_) + +getXmlVersion :: + (MonadIO m, DocumentClass self, GlibString string) => + self -> m (Maybe string) +getXmlVersion self + = liftIO + (({# call webkit_dom_document_get_xml_version #} (toDocument self)) + >>= + maybePeek readUTFString) + +setXmlStandalone :: + (MonadIO m, DocumentClass self) => self -> Bool -> m () +setXmlStandalone self val + = liftIO + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_document_set_xml_standalone #} (toDocument self) + (fromBool val) + errorPtr_) + +getXmlStandalone :: + (MonadIO m, DocumentClass self) => self -> m Bool +getXmlStandalone self + = liftIO + (toBool <$> + ({# call webkit_dom_document_get_xml_standalone #} + (toDocument self))) + +getDocumentURI :: + (MonadIO m, DocumentClass self, GlibString string) => + self -> m (Maybe string) +getDocumentURI self + = liftIO + (({# call webkit_dom_document_get_document_uri #} + (toDocument self)) + >>= + maybePeek readUTFString) + +getDefaultView :: + (MonadIO m, DocumentClass self) => self -> m (Maybe Window) +getDefaultView self + = liftIO + (maybeNull (makeNewGObject mkWindow) + ({# call webkit_dom_document_get_default_view #} + (toDocument self))) + +getStyleSheets :: + (MonadIO m, DocumentClass self) => self -> m (Maybe StyleSheetList) +getStyleSheets self + = liftIO + (maybeNull (makeNewGObject mkStyleSheetList) + ({# call webkit_dom_document_get_style_sheets #} + (toDocument self))) + +setTitle :: + (MonadIO m, DocumentClass self, GlibString string) => + self -> (Maybe string) -> m () +setTitle self val + = liftIO + (maybeWith withUTFString val $ + \ valPtr -> + {# call webkit_dom_document_set_title #} (toDocument self) valPtr) + +getTitle :: + (MonadIO m, DocumentClass self, GlibString string) => + self -> m (Maybe string) +getTitle self + = liftIO + (({# call webkit_dom_document_get_title #} (toDocument self)) >>= + maybePeek readUTFString) + +getReferrer :: + (MonadIO m, DocumentClass self, GlibString string) => + self -> m string +getReferrer self + = liftIO + (({# call webkit_dom_document_get_referrer #} (toDocument self)) + >>= + readUTFString) + +getDomain :: + (MonadIO m, DocumentClass self, GlibString string) => + self -> m string +getDomain self + = liftIO + (({# call webkit_dom_document_get_domain #} (toDocument self)) >>= + readUTFString) + +setCookie :: + (MonadIO m, DocumentClass self, GlibString string) => + self -> (Maybe string) -> m () +setCookie self val + = liftIO + (propagateGError $ + \ errorPtr_ -> + maybeWith withUTFString val $ + \ valPtr -> + {# call webkit_dom_document_set_cookie #} (toDocument self) valPtr + errorPtr_) + +getCookie :: + (MonadIO m, DocumentClass self, GlibString string) => + self -> m (Maybe string) +getCookie self + = liftIO + ((propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_document_get_cookie #} (toDocument self) + errorPtr_) + >>= + maybePeek readUTFString) + +setBody :: + (MonadIO m, HTMLElementClass val, DocumentClass self) => + self -> Maybe val -> m () +setBody self val + = liftIO + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_document_set_body #} (toDocument self) + (maybe (HTMLElement nullForeignPtr) toHTMLElement val) + errorPtr_) + +getBody :: + (MonadIO m, DocumentClass self) => self -> m (Maybe HTMLElement) +getBody self + = liftIO + (maybeNull (makeNewGObject mkHTMLElement) + ({# call webkit_dom_document_get_body #} (toDocument self))) + +getHead :: + (MonadIO m, DocumentClass self) => + self -> m (Maybe HTMLHeadElement) +getHead self + = liftIO + (maybeNull (makeNewGObject mkHTMLHeadElement) + ({# call webkit_dom_document_get_head #} (toDocument self))) + +getImages :: + (MonadIO m, DocumentClass self) => self -> m (Maybe HTMLCollection) +getImages self + = liftIO + (maybeNull (makeNewGObject mkHTMLCollection) + ({# call webkit_dom_document_get_images #} (toDocument self))) + +getApplets :: + (MonadIO m, DocumentClass self) => self -> m (Maybe HTMLCollection) +getApplets self + = liftIO + (maybeNull (makeNewGObject mkHTMLCollection) + ({# call webkit_dom_document_get_applets #} (toDocument self))) + +getLinks :: + (MonadIO m, DocumentClass self) => self -> m (Maybe HTMLCollection) +getLinks self + = liftIO + (maybeNull (makeNewGObject mkHTMLCollection) + ({# call webkit_dom_document_get_links #} (toDocument self))) + +getForms :: + (MonadIO m, DocumentClass self) => self -> m (Maybe HTMLCollection) +getForms self + = liftIO + (maybeNull (makeNewGObject mkHTMLCollection) + ({# call webkit_dom_document_get_forms #} (toDocument self))) + +getAnchors :: + (MonadIO m, DocumentClass self) => self -> m (Maybe HTMLCollection) +getAnchors self + = liftIO + (maybeNull (makeNewGObject mkHTMLCollection) + ({# call webkit_dom_document_get_anchors #} (toDocument self))) + +getLastModified :: + (MonadIO m, DocumentClass self, GlibString string) => + self -> m string +getLastModified self + = liftIO + (({# call webkit_dom_document_get_last_modified #} + (toDocument self)) + >>= + readUTFString) + +setCharset :: + (MonadIO m, DocumentClass self, GlibString string) => + self -> (Maybe string) -> m () +setCharset self val + = liftIO + (maybeWith withUTFString val $ + \ valPtr -> + {# call webkit_dom_document_set_charset #} (toDocument self) + valPtr) + +getCharset :: + (MonadIO m, DocumentClass self, GlibString string) => + self -> m (Maybe string) +getCharset self + = liftIO + (({# call webkit_dom_document_get_charset #} (toDocument self)) >>= + maybePeek readUTFString) + +getDefaultCharset :: + (MonadIO m, DocumentClass self, GlibString string) => + self -> m (Maybe string) +getDefaultCharset self + = liftIO + (({# call webkit_dom_document_get_default_charset #} + (toDocument self)) + >>= + maybePeek readUTFString) + +getReadyState :: + (MonadIO m, DocumentClass self, GlibString string) => + self -> m (Maybe string) +getReadyState self + = liftIO + (({# call webkit_dom_document_get_ready_state #} (toDocument self)) + >>= + maybePeek readUTFString) + +getCharacterSet :: + (MonadIO m, DocumentClass self, GlibString string) => + self -> m (Maybe string) +getCharacterSet self + = liftIO + (({# call webkit_dom_document_get_character_set #} + (toDocument self)) + >>= + maybePeek readUTFString) + +getPreferredStylesheetSet :: + (MonadIO m, DocumentClass self, GlibString string) => + self -> m (Maybe string) +getPreferredStylesheetSet self + = liftIO + (({# call webkit_dom_document_get_preferred_stylesheet_set #} + (toDocument self)) + >>= + maybePeek readUTFString) + +setSelectedStylesheetSet :: + (MonadIO m, DocumentClass self, GlibString string) => + self -> (Maybe string) -> m () +setSelectedStylesheetSet self val + = liftIO + (maybeWith withUTFString val $ + \ valPtr -> + {# call webkit_dom_document_set_selected_stylesheet_set #} + (toDocument self) + valPtr) + +getSelectedStylesheetSet :: + (MonadIO m, DocumentClass self, GlibString string) => + self -> m (Maybe string) +getSelectedStylesheetSet self + = liftIO + (({# call webkit_dom_document_get_selected_stylesheet_set #} + (toDocument self)) + >>= + maybePeek readUTFString) + +getCompatMode :: + (MonadIO m, DocumentClass self, GlibString string) => + self -> m string +getCompatMode self + = liftIO + (({# call webkit_dom_document_get_compat_mode #} (toDocument self)) + >>= + readUTFString) + +getWebkitIsFullScreen :: + (MonadIO m, DocumentClass self) => self -> m Bool +getWebkitIsFullScreen self + = liftIO + (toBool <$> + ({# call webkit_dom_document_get_webkit_is_full_screen #} + (toDocument self))) + +getWebkitFullScreenKeyboardInputAllowed :: + (MonadIO m, DocumentClass self) => self -> m Bool +getWebkitFullScreenKeyboardInputAllowed self + = liftIO + (toBool <$> + ({# call + webkit_dom_document_get_webkit_full_screen_keyboard_input_allowed + #} + (toDocument self))) + +getWebkitCurrentFullScreenElement :: + (MonadIO m, DocumentClass self) => self -> m (Maybe Element) +getWebkitCurrentFullScreenElement self + = liftIO + (maybeNull (makeNewGObject mkElement) + ({# call webkit_dom_document_get_webkit_current_full_screen_element + #} + (toDocument self))) + +#if WEBKIT_CHECK_VERSION(2,2,2) +getWebkitFullscreenEnabled :: + (MonadIO m, DocumentClass self) => self -> m Bool +getWebkitFullscreenEnabled self + = liftIO + (toBool <$> + ({# call webkit_dom_document_get_webkit_fullscreen_enabled #} + (toDocument self))) + +getWebkitFullscreenElement :: + (MonadIO m, DocumentClass self) => self -> m (Maybe Element) +getWebkitFullscreenElement self + = liftIO + (maybeNull (makeNewGObject mkElement) + ({# call webkit_dom_document_get_webkit_fullscreen_element #} + (toDocument self))) +#endif + +abort :: (DocumentClass self) => EventName self UIEvent +abort = EventName "abort" + +blur :: (DocumentClass self) => EventName self UIEvent +blur = EventName "blur" + +change :: (DocumentClass self) => EventName self Event +change = EventName "change" + +click :: (DocumentClass self) => EventName self MouseEvent +click = EventName "click" + +contextMenu :: (DocumentClass self) => EventName self MouseEvent +contextMenu = EventName "contextmenu" + +dblClick :: (DocumentClass self) => EventName self MouseEvent +dblClick = EventName "dblclick" + +drag :: (DocumentClass self) => EventName self MouseEvent +drag = EventName "drag" + +dragEnd :: (DocumentClass self) => EventName self MouseEvent +dragEnd = EventName "dragend" + +dragEnter :: (DocumentClass self) => EventName self MouseEvent +dragEnter = EventName "dragenter" + +dragLeave :: (DocumentClass self) => EventName self MouseEvent +dragLeave = EventName "dragleave" + +dragOver :: (DocumentClass self) => EventName self MouseEvent +dragOver = EventName "dragover" + +dragStart :: (DocumentClass self) => EventName self MouseEvent +dragStart = EventName "dragstart" + +drop :: (DocumentClass self) => EventName self MouseEvent +drop = EventName "drop" + +error :: (DocumentClass self) => EventName self UIEvent +error = EventName "error" + +focus :: (DocumentClass self) => EventName self UIEvent +focus = EventName "focus" + +input :: (DocumentClass self) => EventName self Event +input = EventName "input" + +invalid :: (DocumentClass self) => EventName self Event +invalid = EventName "invalid" + +#if WEBKIT_CHECK_VERSION(2,2,2) +keyDown :: (DocumentClass self) => EventName self KeyboardEvent +keyDown = EventName "keydown" + +keyPress :: (DocumentClass self) => EventName self KeyboardEvent +keyPress = EventName "keypress" + +keyUp :: (DocumentClass self) => EventName self KeyboardEvent +keyUp = EventName "keyup" +#endif + +load :: (DocumentClass self) => EventName self UIEvent +load = EventName "load" + +mouseDown :: (DocumentClass self) => EventName self MouseEvent +mouseDown = EventName "mousedown" + +mouseEnter :: (DocumentClass self) => EventName self MouseEvent +mouseEnter = EventName "mouseenter" + +mouseLeave :: (DocumentClass self) => EventName self MouseEvent +mouseLeave = EventName "mouseleave" + +mouseMove :: (DocumentClass self) => EventName self MouseEvent +mouseMove = EventName "mousemove" + +mouseOut :: (DocumentClass self) => EventName self MouseEvent +mouseOut = EventName "mouseout" + +mouseOver :: (DocumentClass self) => EventName self MouseEvent +mouseOver = EventName "mouseover" + +mouseUp :: (DocumentClass self) => EventName self MouseEvent +mouseUp = EventName "mouseup" + +mouseWheel :: (DocumentClass self) => EventName self MouseEvent +mouseWheel = EventName "mousewheel" + +readyStateChange :: (DocumentClass self) => EventName self Event +readyStateChange = EventName "readystatechange" + +scroll :: (DocumentClass self) => EventName self UIEvent +scroll = EventName "scroll" + +select :: (DocumentClass self) => EventName self UIEvent +select = EventName "select" + +submit :: (DocumentClass self) => EventName self Event +submit = EventName "submit" + +#if WEBKIT_CHECK_VERSION(2,4,0) +wheel :: (DocumentClass self) => EventName self WheelEvent +wheel = EventName "wheel" +#endif + +beforeCut :: (DocumentClass self) => EventName self Event +beforeCut = EventName "beforecut" + +cut :: (DocumentClass self) => EventName self Event +cut = EventName "cut" + +beforeCopy :: (DocumentClass self) => EventName self Event +beforeCopy = EventName "beforecopy" + +copy :: (DocumentClass self) => EventName self Event +copy = EventName "copy" + +beforePaste :: (DocumentClass self) => EventName self Event +beforePaste = EventName "beforepaste" + +paste :: (DocumentClass self) => EventName self Event +paste = EventName "paste" + +reset :: (DocumentClass self) => EventName self Event +reset = EventName "reset" + +search :: (DocumentClass self) => EventName self Event +search = EventName "search" + +selectStart :: (DocumentClass self) => EventName self Event +selectStart = EventName "selectstart" + +selectionchange :: (DocumentClass self) => EventName self Event +selectionchange = EventName "selectionchange" + +touchStart :: (DocumentClass self) => EventName self UIEvent +touchStart = EventName "touchstart" + +touchMove :: (DocumentClass self) => EventName self UIEvent +touchMove = EventName "touchmove" + +touchEnd :: (DocumentClass self) => EventName self UIEvent +touchEnd = EventName "touchend" + +touchCancel :: (DocumentClass self) => EventName self UIEvent +touchCancel = EventName "touchcancel" + +webKitFullscreenChange :: + (DocumentClass self) => EventName self Event +webKitFullscreenChange = EventName "webkitfullscreenchange" + +webKitFullscreenError :: + (DocumentClass self) => EventName self Event +webKitFullscreenError = EventName "webkitfullscreenerror" + +pointerlockchange :: (DocumentClass self) => EventName self Event +pointerlockchange = EventName "pointerlockchange" + +pointerlockerror :: (DocumentClass self) => EventName self Event +pointerlockerror = EventName "pointerlockerror" + +securitypolicyviolation :: + (DocumentClass self) => EventName self Event +securitypolicyviolation = EventName "securitypolicyviolation" + +webKitWillRevealBottom :: + (DocumentClass self) => EventName self Event +webKitWillRevealBottom = EventName "webkitwillrevealbottom" + +webKitWillRevealLeft :: + (DocumentClass self) => EventName self Event +webKitWillRevealLeft = EventName "webkitwillrevealleft" + +webKitWillRevealRight :: + (DocumentClass self) => EventName self Event +webKitWillRevealRight = EventName "webkitwillrevealright" + +webKitWillRevealTop :: (DocumentClass self) => EventName self Event +webKitWillRevealTop = EventName "webkitwillrevealtop" + +getVisibilityState :: + (MonadIO m, DocumentClass self, GlibString string) => + self -> m string +getVisibilityState self + = liftIO +#if WEBKIT_CHECK_VERSION(2,2,2) + (({# call webkit_dom_document_get_visibility_state #} +#else + (({# call webkit_dom_document_get_webkit_visibility_state #} +#endif + (toDocument self)) + >>= + readUTFString) + +getHidden :: (MonadIO m, DocumentClass self) => self -> m Bool +getHidden self + = liftIO + (toBool <$> +#if WEBKIT_CHECK_VERSION(2,2,2) + ({# call webkit_dom_document_get_hidden #} (toDocument self))) +#else + ({# call webkit_dom_document_get_webkit_hidden #} (toDocument self))) +#endif + +#if WEBKIT_CHECK_VERSION(1,10,0) +getSecurityPolicy :: + (MonadIO m, DocumentClass self) => self -> m (Maybe SecurityPolicy) +getSecurityPolicy self + = liftIO + (maybeNull (makeNewGObject mkSecurityPolicy) + ({# call webkit_dom_document_get_security_policy #} + (toDocument self))) +#endif + +#if WEBKIT_CHECK_VERSION(2,2,2) +getCurrentScript :: + (MonadIO m, DocumentClass self) => + self -> m (Maybe HTMLScriptElement) +getCurrentScript self + = liftIO + (maybeNull (makeNewGObject mkHTMLScriptElement) + ({# call webkit_dom_document_get_current_script #} + (toDocument self))) +#endif diff --git a/Graphics/UI/Gtk/WebKit/DOM/DocumentType.chs b/Graphics/UI/Gtk/WebKit/DOM/DocumentType.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/DocumentType.chs @@ -0,0 +1,85 @@ +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 + + +getName :: + (MonadIO m, DocumentTypeClass self, GlibString string) => + self -> m string +getName self + = liftIO + (({# call webkit_dom_document_type_get_name #} + (toDocumentType self)) + >>= + readUTFString) + +getEntities :: + (MonadIO m, DocumentTypeClass self) => + self -> m (Maybe NamedNodeMap) +getEntities self + = liftIO + (maybeNull (makeNewGObject mkNamedNodeMap) + ({# call webkit_dom_document_type_get_entities #} + (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))) + +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) + +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) + +getInternalSubset :: + (MonadIO m, DocumentTypeClass self, GlibString string) => + self -> m (Maybe string) +getInternalSubset self + = liftIO + (({# call webkit_dom_document_type_get_internal_subset #} + (toDocumentType self)) + >>= + maybePeek readUTFString) diff --git a/Graphics/UI/Gtk/WebKit/DOM/Element.chs b/Graphics/UI/Gtk/WebKit/DOM/Element.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/Element.chs @@ -0,0 +1,971 @@ +module Graphics.UI.Gtk.WebKit.DOM.Element( +getAttribute, +setAttribute, +removeAttribute, +getAttributeNode, +setAttributeNode, +removeAttributeNode, +getElementsByTagName, +#if WEBKIT_CHECK_VERSION(2,2,2) +hasAttributes, +#endif +getAttributeNS, +setAttributeNS, +removeAttributeNS, +getElementsByTagNameNS, +getAttributeNodeNS, +setAttributeNodeNS, +hasAttribute, +hasAttributeNS, +focus, +blur, +scrollIntoView, +scrollIntoViewIfNeeded, +scrollByLines, +scrollByPages, +getElementsByClassName, +querySelector, +querySelectorAll, +#if WEBKIT_CHECK_VERSION(99,0,0) +matches, +closest, +#endif +webkitMatchesSelector, +#if WEBKIT_CHECK_VERSION(2,2,2) +webkitRequestFullScreen, +webkitRequestFullscreen, +requestPointerLock, +#endif +#if WEBKIT_CHECK_VERSION(99,0,0) +webkitGetRegionFlowRanges, +#endif +pattern ALLOW_KEYBOARD_INPUT, +getTagName, +#if WEBKIT_CHECK_VERSION(2,2,2) +getAttributes, +#endif +getStyle, +#if WEBKIT_CHECK_VERSION(2,2,2) +setId, +getId, +#endif +getOffsetLeft, +getOffsetTop, +getOffsetWidth, +getOffsetHeight, +getClientLeft, +getClientTop, +getClientWidth, +getClientHeight, +setScrollLeft, +getScrollLeft, +setScrollTop, +getScrollTop, +getScrollWidth, +getScrollHeight, +getOffsetParent, +setInnerHTML, +getInnerHTML, +setOuterHTML, +getOuterHTML, +#if WEBKIT_CHECK_VERSION(2,2,2) +setClassName, +getClassName, +getClassList, +#endif +getFirstElementChild, +getLastElementChild, +getPreviousElementSibling, +getNextElementSibling, +getChildElementCount, +#if WEBKIT_CHECK_VERSION(2,2,2) +getWebkitRegionOverset, +#endif +abort, +blurEvent, +change, +click, +contextMenu, +dblClick, +drag, +dragEnd, +dragEnter, +dragLeave, +dragOver, +dragStart, +drop, +error, +focusEvent, +input, +invalid, +#if WEBKIT_CHECK_VERSION(2,2,2) +keyDown, +keyPress, +keyUp, +#endif +load, +mouseDown, +mouseEnter, +mouseLeave, +mouseMove, +mouseOut, +mouseOver, +mouseUp, +mouseWheel, +scroll, +select, +submit, +#if WEBKIT_CHECK_VERSION(2,4,0) +wheel, +#endif +beforeCut, +cut, +beforeCopy, +copy, +beforePaste, +paste, +reset, +search, +selectStart, +touchStart, +touchMove, +touchEnd, +touchCancel, +webKitFullscreenChange, +webKitFullscreenError, +webKitWillRevealBottom, +webKitWillRevealLeft, +webKitWillRevealRight, +webKitWillRevealTop, +Element, +castToElement, +gTypeElement, +ElementClass, +toElement, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures +import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + + +getAttribute :: + (MonadIO m, ElementClass self, GlibString string) => + self -> string -> m (Maybe string) +getAttribute self name + = liftIO + ((withUTFString name $ + \ namePtr -> + {# call webkit_dom_element_get_attribute #} (toElement self) + namePtr) + >>= + maybePeek readUTFString) + +setAttribute :: + (MonadIO m, ElementClass self, GlibString string) => + self -> string -> string -> m () +setAttribute self name value + = liftIO + (propagateGError $ + \ errorPtr_ -> + withUTFString value $ + \ valuePtr -> + withUTFString name $ + \ namePtr -> + {# call webkit_dom_element_set_attribute #} (toElement self) + namePtr + valuePtr + errorPtr_) + +removeAttribute :: + (MonadIO m, ElementClass self, GlibString string) => + self -> string -> m () +removeAttribute self name + = liftIO + (withUTFString name $ + \ namePtr -> + {# call webkit_dom_element_remove_attribute #} (toElement self) + namePtr) + +getAttributeNode :: + (MonadIO m, ElementClass self, GlibString string) => + self -> string -> m (Maybe Attr) +getAttributeNode self name + = liftIO + (maybeNull (makeNewGObject mkAttr) + (withUTFString name $ + \ namePtr -> + {# call webkit_dom_element_get_attribute_node #} (toElement self) + namePtr)) + +setAttributeNode :: + (MonadIO m, ElementClass self, AttrClass newAttr) => + self -> Maybe newAttr -> m (Maybe Attr) +setAttributeNode self newAttr + = liftIO + (maybeNull (makeNewGObject mkAttr) + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_element_set_attribute_node #} (toElement self) + (maybe (Attr nullForeignPtr) toAttr newAttr) + errorPtr_)) + +removeAttributeNode :: + (MonadIO m, ElementClass self, AttrClass oldAttr) => + self -> Maybe oldAttr -> m (Maybe Attr) +removeAttributeNode self oldAttr + = liftIO + (maybeNull (makeNewGObject mkAttr) + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_element_remove_attribute_node #} + (toElement self) + (maybe (Attr nullForeignPtr) toAttr oldAttr) + errorPtr_)) + +getElementsByTagName :: + (MonadIO m, ElementClass self, GlibString string) => + self -> string -> m (Maybe NodeList) +getElementsByTagName self name + = liftIO + (maybeNull (makeNewGObject mkNodeList) + (withUTFString name $ + \ namePtr -> + {# call webkit_dom_element_get_elements_by_tag_name #} + (toElement self) + namePtr)) + +#if WEBKIT_CHECK_VERSION(2,2,2) +hasAttributes :: (MonadIO m, ElementClass self) => self -> m Bool +hasAttributes self + = liftIO + (toBool <$> + ({# call webkit_dom_element_has_attributes #} (toElement self))) +#endif + +getAttributeNS :: + (MonadIO m, ElementClass self, GlibString string) => + self -> (Maybe string) -> string -> m string +getAttributeNS self namespaceURI localName + = liftIO + ((withUTFString localName $ + \ localNamePtr -> + maybeWith withUTFString namespaceURI $ + \ namespaceURIPtr -> + {# call webkit_dom_element_get_attribute_ns #} (toElement self) + namespaceURIPtr + localNamePtr) + >>= + readUTFString) + +setAttributeNS :: + (MonadIO m, ElementClass self, GlibString string) => + self -> (Maybe string) -> string -> string -> m () +setAttributeNS self namespaceURI qualifiedName value + = liftIO + (propagateGError $ + \ errorPtr_ -> + withUTFString value $ + \ valuePtr -> + withUTFString qualifiedName $ + \ qualifiedNamePtr -> + maybeWith withUTFString namespaceURI $ + \ namespaceURIPtr -> + {# call webkit_dom_element_set_attribute_ns #} (toElement self) + namespaceURIPtr + qualifiedNamePtr + valuePtr + errorPtr_) + +removeAttributeNS :: + (MonadIO m, ElementClass self, GlibString string) => + self -> (Maybe string) -> string -> m () +removeAttributeNS self namespaceURI localName + = liftIO + (withUTFString localName $ + \ localNamePtr -> + maybeWith withUTFString namespaceURI $ + \ namespaceURIPtr -> + {# call webkit_dom_element_remove_attribute_ns #} (toElement self) + namespaceURIPtr + localNamePtr) + +getElementsByTagNameNS :: + (MonadIO m, ElementClass self, GlibString string) => + self -> (Maybe string) -> string -> m (Maybe NodeList) +getElementsByTagNameNS self namespaceURI localName + = liftIO + (maybeNull (makeNewGObject mkNodeList) + (withUTFString localName $ + \ localNamePtr -> + maybeWith withUTFString namespaceURI $ + \ namespaceURIPtr -> + {# call webkit_dom_element_get_elements_by_tag_name_ns #} + (toElement self) + namespaceURIPtr + localNamePtr)) + +getAttributeNodeNS :: + (MonadIO m, ElementClass self, GlibString string) => + self -> (Maybe string) -> string -> m (Maybe Attr) +getAttributeNodeNS self namespaceURI localName + = liftIO + (maybeNull (makeNewGObject mkAttr) + (withUTFString localName $ + \ localNamePtr -> + maybeWith withUTFString namespaceURI $ + \ namespaceURIPtr -> + {# call webkit_dom_element_get_attribute_node_ns #} + (toElement self) + namespaceURIPtr + localNamePtr)) + +setAttributeNodeNS :: + (MonadIO m, ElementClass self, AttrClass newAttr) => + self -> Maybe newAttr -> m (Maybe Attr) +setAttributeNodeNS self newAttr + = liftIO + (maybeNull (makeNewGObject mkAttr) + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_element_set_attribute_node_ns #} + (toElement self) + (maybe (Attr nullForeignPtr) toAttr newAttr) + errorPtr_)) + +hasAttribute :: + (MonadIO m, ElementClass self, GlibString string) => + self -> string -> m Bool +hasAttribute self name + = liftIO + (toBool <$> + (withUTFString name $ + \ namePtr -> + {# call webkit_dom_element_has_attribute #} (toElement self) + namePtr)) + +hasAttributeNS :: + (MonadIO m, ElementClass self, GlibString string) => + self -> (Maybe string) -> string -> m Bool +hasAttributeNS self namespaceURI localName + = liftIO + (toBool <$> + (withUTFString localName $ + \ localNamePtr -> + maybeWith withUTFString namespaceURI $ + \ namespaceURIPtr -> + {# call webkit_dom_element_has_attribute_ns #} (toElement self) + namespaceURIPtr + localNamePtr)) + +focus :: (MonadIO m, ElementClass self) => self -> m () +focus self + = liftIO ({# call webkit_dom_element_focus #} (toElement self)) + +blur :: (MonadIO m, ElementClass self) => self -> m () +blur self + = liftIO ({# call webkit_dom_element_blur #} (toElement self)) + +scrollIntoView :: + (MonadIO m, ElementClass self) => self -> Bool -> m () +scrollIntoView self alignWithTop + = liftIO + ({# call webkit_dom_element_scroll_into_view #} (toElement self) + (fromBool alignWithTop)) + +scrollIntoViewIfNeeded :: + (MonadIO m, ElementClass self) => self -> Bool -> m () +scrollIntoViewIfNeeded self centerIfNeeded + = liftIO + ({# call webkit_dom_element_scroll_into_view_if_needed #} + (toElement self) + (fromBool centerIfNeeded)) + +scrollByLines :: + (MonadIO m, ElementClass self) => self -> Int -> m () +scrollByLines self lines + = liftIO + ({# call webkit_dom_element_scroll_by_lines #} (toElement self) + (fromIntegral lines)) + +scrollByPages :: + (MonadIO m, ElementClass self) => self -> Int -> m () +scrollByPages self pages + = liftIO + ({# call webkit_dom_element_scroll_by_pages #} (toElement self) + (fromIntegral pages)) + +getElementsByClassName :: + (MonadIO m, ElementClass self, GlibString string) => + self -> string -> m (Maybe NodeList) +getElementsByClassName self name + = liftIO + (maybeNull (makeNewGObject mkNodeList) + (withUTFString name $ + \ namePtr -> + {# call webkit_dom_element_get_elements_by_class_name #} + (toElement self) + namePtr)) + +querySelector :: + (MonadIO m, ElementClass self, GlibString string) => + self -> string -> m (Maybe Element) +querySelector self selectors + = liftIO + (maybeNull (makeNewGObject mkElement) + (propagateGError $ + \ errorPtr_ -> + withUTFString selectors $ + \ selectorsPtr -> + {# call webkit_dom_element_query_selector #} (toElement self) + selectorsPtr + errorPtr_)) + +querySelectorAll :: + (MonadIO m, ElementClass self, GlibString string) => + self -> string -> m (Maybe NodeList) +querySelectorAll self selectors + = liftIO + (maybeNull (makeNewGObject mkNodeList) + (propagateGError $ + \ errorPtr_ -> + withUTFString selectors $ + \ selectorsPtr -> + {# call webkit_dom_element_query_selector_all #} (toElement self) + selectorsPtr + errorPtr_)) + +#if WEBKIT_CHECK_VERSION(99,0,0) +matches :: + (MonadIO m, ElementClass self, GlibString string) => + self -> string -> m Bool +matches self selectors + = liftIO + (toBool <$> + (propagateGError $ + \ errorPtr_ -> + withUTFString selectors $ + \ selectorsPtr -> + {# call webkit_dom_element_matches #} (toElement self) selectorsPtr + errorPtr_)) + +closest :: + (MonadIO m, ElementClass self, GlibString string) => + self -> string -> m (Maybe Element) +closest self selectors + = liftIO + (maybeNull (makeNewGObject mkElement) + (propagateGError $ + \ errorPtr_ -> + withUTFString selectors $ + \ selectorsPtr -> + {# call webkit_dom_element_closest #} (toElement self) selectorsPtr + errorPtr_)) +#endif + +webkitMatchesSelector :: + (MonadIO m, ElementClass self, GlibString string) => + self -> string -> m Bool +webkitMatchesSelector self selectors + = liftIO + (toBool <$> + (propagateGError $ + \ errorPtr_ -> + withUTFString selectors $ + \ selectorsPtr -> + {# call webkit_dom_element_webkit_matches_selector #} + (toElement self) + selectorsPtr + errorPtr_)) + +#if WEBKIT_CHECK_VERSION(2,2,2) +webkitRequestFullScreen :: + (MonadIO m, ElementClass self) => self -> Word -> m () +webkitRequestFullScreen self flags + = liftIO + ({# call webkit_dom_element_webkit_request_full_screen #} + (toElement self) + (fromIntegral flags)) + +webkitRequestFullscreen :: + (MonadIO m, ElementClass self) => self -> m () +webkitRequestFullscreen self + = liftIO + ({# call webkit_dom_element_webkit_request_fullscreen #} + (toElement self)) + +requestPointerLock :: + (MonadIO m, ElementClass self) => self -> m () +requestPointerLock self + = liftIO +#if WEBKIT_CHECK_VERSION(2,6,0) + ({# call webkit_dom_element_request_pointer_lock #} +#else + ({# call webkit_dom_element_webkit_request_pointer_lock #} +#endif + (toElement self)) +#endif + +#if WEBKIT_CHECK_VERSION(99,0,0) +webkitGetRegionFlowRanges :: + (MonadIO m, ElementClass self) => self -> m [Maybe Range] +webkitGetRegionFlowRanges self + = liftIO + ({# call webkit_dom_element_webkit_get_region_flow_ranges #} + (toElement self)) +#endif +pattern ALLOW_KEYBOARD_INPUT = 1 + +getTagName :: + (MonadIO m, ElementClass self, GlibString string) => + self -> m (Maybe string) +getTagName self + = liftIO + (({# call webkit_dom_element_get_tag_name #} (toElement self)) >>= + maybePeek readUTFString) + +#if WEBKIT_CHECK_VERSION(2,2,2) +getAttributes :: + (MonadIO m, ElementClass self) => self -> m (Maybe NamedNodeMap) +getAttributes self + = liftIO + (maybeNull (makeNewGObject mkNamedNodeMap) + ({# call webkit_dom_element_get_attributes #} (toElement self))) +#endif + +getStyle :: + (MonadIO m, ElementClass self) => + self -> m (Maybe CSSStyleDeclaration) +getStyle self + = liftIO + (maybeNull (makeNewGObject mkCSSStyleDeclaration) + ({# call webkit_dom_element_get_style #} (toElement self))) + +#if WEBKIT_CHECK_VERSION(2,2,2) +setId :: + (MonadIO m, ElementClass self, GlibString string) => + self -> string -> m () +setId self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_element_set_id #} (toElement self) valPtr) + +getId :: + (MonadIO m, ElementClass self, GlibString string) => + self -> m string +getId self + = liftIO + (({# call webkit_dom_element_get_id #} (toElement self)) >>= + readUTFString) +#endif + +getOffsetLeft :: (MonadIO m, ElementClass self) => self -> m Double +getOffsetLeft self + = liftIO + (realToFrac <$> + ({# call webkit_dom_element_get_offset_left #} (toElement self))) + +getOffsetTop :: (MonadIO m, ElementClass self) => self -> m Double +getOffsetTop self + = liftIO + (realToFrac <$> + ({# call webkit_dom_element_get_offset_top #} (toElement self))) + +getOffsetWidth :: + (MonadIO m, ElementClass self) => self -> m Double +getOffsetWidth self + = liftIO + (realToFrac <$> + ({# call webkit_dom_element_get_offset_width #} (toElement self))) + +getOffsetHeight :: + (MonadIO m, ElementClass self) => self -> m Double +getOffsetHeight self + = liftIO + (realToFrac <$> + ({# call webkit_dom_element_get_offset_height #} (toElement self))) + +getClientLeft :: (MonadIO m, ElementClass self) => self -> m Double +getClientLeft self + = liftIO + (realToFrac <$> + ({# call webkit_dom_element_get_client_left #} (toElement self))) + +getClientTop :: (MonadIO m, ElementClass self) => self -> m Double +getClientTop self + = liftIO + (realToFrac <$> + ({# call webkit_dom_element_get_client_top #} (toElement self))) + +getClientWidth :: + (MonadIO m, ElementClass self) => self -> m Double +getClientWidth self + = liftIO + (realToFrac <$> + ({# call webkit_dom_element_get_client_width #} (toElement self))) + +getClientHeight :: + (MonadIO m, ElementClass self) => self -> m Double +getClientHeight self + = liftIO + (realToFrac <$> + ({# call webkit_dom_element_get_client_height #} (toElement self))) + +setScrollLeft :: + (MonadIO m, ElementClass self) => self -> Int -> m () +setScrollLeft self val + = liftIO + ({# call webkit_dom_element_set_scroll_left #} (toElement self) + (fromIntegral val)) + +getScrollLeft :: (MonadIO m, ElementClass self) => self -> m Int +getScrollLeft self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_element_get_scroll_left #} (toElement self))) + +setScrollTop :: + (MonadIO m, ElementClass self) => self -> Int -> m () +setScrollTop self val + = liftIO + ({# call webkit_dom_element_set_scroll_top #} (toElement self) + (fromIntegral val)) + +getScrollTop :: (MonadIO m, ElementClass self) => self -> m Int +getScrollTop self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_element_get_scroll_top #} (toElement self))) + +getScrollWidth :: (MonadIO m, ElementClass self) => self -> m Int +getScrollWidth self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_element_get_scroll_width #} (toElement self))) + +getScrollHeight :: (MonadIO m, ElementClass self) => self -> m Int +getScrollHeight self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_element_get_scroll_height #} (toElement self))) + +getOffsetParent :: + (MonadIO m, ElementClass self) => self -> m (Maybe Element) +getOffsetParent self + = liftIO + (maybeNull (makeNewGObject mkElement) + ({# call webkit_dom_element_get_offset_parent #} (toElement self))) + +setInnerHTML :: + (MonadIO m, ElementClass self, GlibString string) => + self -> (Maybe string) -> m () +setInnerHTML self val + = liftIO + (propagateGError $ + \ errorPtr_ -> + maybeWith withUTFString val $ + \ valPtr -> +#if WEBKIT_CHECK_VERSION(2,8,0) + {# call webkit_dom_element_set_inner_html #} (toElement self) +#else + ({# call webkit_dom_html_element_set_inner_html #} . castToHTMLElement) (toElement self) +#endif + valPtr + errorPtr_) + +getInnerHTML :: + (MonadIO m, ElementClass self, GlibString string) => + self -> m (Maybe string) +getInnerHTML self + = liftIO +#if WEBKIT_CHECK_VERSION(2,8,0) + (({# call webkit_dom_element_get_inner_html #} (toElement self)) +#else + ((({# call webkit_dom_html_element_get_inner_html #} . castToHTMLElement) (toElement self)) +#endif + >>= + maybePeek readUTFString) + +setOuterHTML :: + (MonadIO m, ElementClass self, GlibString string) => + self -> (Maybe string) -> m () +setOuterHTML self val + = liftIO + (propagateGError $ + \ errorPtr_ -> + maybeWith withUTFString val $ + \ valPtr -> +#if WEBKIT_CHECK_VERSION(2,8,0) + {# call webkit_dom_element_set_outer_html #} (toElement self) +#else + ({# call webkit_dom_html_element_set_outer_html #} . castToHTMLElement) (toElement self) +#endif + valPtr + errorPtr_) + +getOuterHTML :: + (MonadIO m, ElementClass self, GlibString string) => + self -> m (Maybe string) +getOuterHTML self + = liftIO +#if WEBKIT_CHECK_VERSION(2,8,0) + (({# call webkit_dom_element_get_outer_html #} (toElement self)) +#else + ((({# call webkit_dom_html_element_get_outer_html #} . castToHTMLElement) (toElement self)) +#endif + >>= + maybePeek readUTFString) + +#if WEBKIT_CHECK_VERSION(2,2,2) +setClassName :: + (MonadIO m, ElementClass self, GlibString string) => + self -> string -> m () +setClassName self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_element_set_class_name #} (toElement self) + valPtr) + +getClassName :: + (MonadIO m, ElementClass self, GlibString string) => + self -> m string +getClassName self + = liftIO + (({# call webkit_dom_element_get_class_name #} (toElement self)) + >>= + readUTFString) + +getClassList :: + (MonadIO m, ElementClass self) => self -> m (Maybe DOMTokenList) +getClassList self + = liftIO + (maybeNull (makeNewGObject mkDOMTokenList) + ({# call webkit_dom_element_get_class_list #} (toElement self))) +#endif + +getFirstElementChild :: + (MonadIO m, ElementClass self) => self -> m (Maybe Element) +getFirstElementChild self + = liftIO + (maybeNull (makeNewGObject mkElement) + ({# call webkit_dom_element_get_first_element_child #} + (toElement self))) + +getLastElementChild :: + (MonadIO m, ElementClass self) => self -> m (Maybe Element) +getLastElementChild self + = liftIO + (maybeNull (makeNewGObject mkElement) + ({# call webkit_dom_element_get_last_element_child #} + (toElement self))) + +getPreviousElementSibling :: + (MonadIO m, ElementClass self) => self -> m (Maybe Element) +getPreviousElementSibling self + = liftIO + (maybeNull (makeNewGObject mkElement) + ({# call webkit_dom_element_get_previous_element_sibling #} + (toElement self))) + +getNextElementSibling :: + (MonadIO m, ElementClass self) => self -> m (Maybe Element) +getNextElementSibling self + = liftIO + (maybeNull (makeNewGObject mkElement) + ({# call webkit_dom_element_get_next_element_sibling #} + (toElement self))) + +getChildElementCount :: + (MonadIO m, ElementClass self) => self -> m Word +getChildElementCount self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_element_get_child_element_count #} + (toElement self))) + +#if WEBKIT_CHECK_VERSION(2,2,2) +getWebkitRegionOverset :: + (MonadIO m, ElementClass self, GlibString string) => + self -> m string +getWebkitRegionOverset self + = liftIO + (({# call webkit_dom_element_get_webkit_region_overset #} + (toElement self)) + >>= + readUTFString) +#endif + +abort :: (ElementClass self) => EventName self UIEvent +abort = EventName "abort" + +blurEvent :: (ElementClass self) => EventName self UIEvent +blurEvent = EventName "blur" + +change :: (ElementClass self) => EventName self Event +change = EventName "change" + +click :: (ElementClass self) => EventName self MouseEvent +click = EventName "click" + +contextMenu :: (ElementClass self) => EventName self MouseEvent +contextMenu = EventName "contextmenu" + +dblClick :: (ElementClass self) => EventName self MouseEvent +dblClick = EventName "dblclick" + +drag :: (ElementClass self) => EventName self MouseEvent +drag = EventName "drag" + +dragEnd :: (ElementClass self) => EventName self MouseEvent +dragEnd = EventName "dragend" + +dragEnter :: (ElementClass self) => EventName self MouseEvent +dragEnter = EventName "dragenter" + +dragLeave :: (ElementClass self) => EventName self MouseEvent +dragLeave = EventName "dragleave" + +dragOver :: (ElementClass self) => EventName self MouseEvent +dragOver = EventName "dragover" + +dragStart :: (ElementClass self) => EventName self MouseEvent +dragStart = EventName "dragstart" + +drop :: (ElementClass self) => EventName self MouseEvent +drop = EventName "drop" + +error :: (ElementClass self) => EventName self UIEvent +error = EventName "error" + +focusEvent :: (ElementClass self) => EventName self UIEvent +focusEvent = EventName "focus" + +input :: (ElementClass self) => EventName self Event +input = EventName "input" + +invalid :: (ElementClass self) => EventName self Event +invalid = EventName "invalid" + +#if WEBKIT_CHECK_VERSION(2,2,2) +keyDown :: (ElementClass self) => EventName self KeyboardEvent +keyDown = EventName "keydown" + +keyPress :: (ElementClass self) => EventName self KeyboardEvent +keyPress = EventName "keypress" + +keyUp :: (ElementClass self) => EventName self KeyboardEvent +keyUp = EventName "keyup" +#endif + +load :: (ElementClass self) => EventName self UIEvent +load = EventName "load" + +mouseDown :: (ElementClass self) => EventName self MouseEvent +mouseDown = EventName "mousedown" + +mouseEnter :: (ElementClass self) => EventName self MouseEvent +mouseEnter = EventName "mouseenter" + +mouseLeave :: (ElementClass self) => EventName self MouseEvent +mouseLeave = EventName "mouseleave" + +mouseMove :: (ElementClass self) => EventName self MouseEvent +mouseMove = EventName "mousemove" + +mouseOut :: (ElementClass self) => EventName self MouseEvent +mouseOut = EventName "mouseout" + +mouseOver :: (ElementClass self) => EventName self MouseEvent +mouseOver = EventName "mouseover" + +mouseUp :: (ElementClass self) => EventName self MouseEvent +mouseUp = EventName "mouseup" + +mouseWheel :: (ElementClass self) => EventName self MouseEvent +mouseWheel = EventName "mousewheel" + +scroll :: (ElementClass self) => EventName self UIEvent +scroll = EventName "scroll" + +select :: (ElementClass self) => EventName self UIEvent +select = EventName "select" + +submit :: (ElementClass self) => EventName self Event +submit = EventName "submit" + +#if WEBKIT_CHECK_VERSION(2,4,0) +wheel :: (ElementClass self) => EventName self WheelEvent +wheel = EventName "wheel" +#endif + +beforeCut :: (ElementClass self) => EventName self Event +beforeCut = EventName "beforecut" + +cut :: (ElementClass self) => EventName self Event +cut = EventName "cut" + +beforeCopy :: (ElementClass self) => EventName self Event +beforeCopy = EventName "beforecopy" + +copy :: (ElementClass self) => EventName self Event +copy = EventName "copy" + +beforePaste :: (ElementClass self) => EventName self Event +beforePaste = EventName "beforepaste" + +paste :: (ElementClass self) => EventName self Event +paste = EventName "paste" + +reset :: (ElementClass self) => EventName self Event +reset = EventName "reset" + +search :: (ElementClass self) => EventName self Event +search = EventName "search" + +selectStart :: (ElementClass self) => EventName self Event +selectStart = EventName "selectstart" + +touchStart :: (ElementClass self) => EventName self UIEvent +touchStart = EventName "touchstart" + +touchMove :: (ElementClass self) => EventName self UIEvent +touchMove = EventName "touchmove" + +touchEnd :: (ElementClass self) => EventName self UIEvent +touchEnd = EventName "touchend" + +touchCancel :: (ElementClass self) => EventName self UIEvent +touchCancel = EventName "touchcancel" + +webKitFullscreenChange :: + (ElementClass self) => EventName self Event +webKitFullscreenChange = EventName "webkitfullscreenchange" + +webKitFullscreenError :: + (ElementClass self) => EventName self Event +webKitFullscreenError = EventName "webkitfullscreenerror" + +webKitWillRevealBottom :: + (ElementClass self) => EventName self Event +webKitWillRevealBottom = EventName "webkitwillrevealbottom" + +webKitWillRevealLeft :: (ElementClass self) => EventName self Event +webKitWillRevealLeft = EventName "webkitwillrevealleft" + +webKitWillRevealRight :: + (ElementClass self) => EventName self Event +webKitWillRevealRight = EventName "webkitwillrevealright" + +webKitWillRevealTop :: (ElementClass self) => EventName self Event +webKitWillRevealTop = EventName "webkitwillrevealtop" diff --git a/Graphics/UI/Gtk/WebKit/DOM/Enums.hs b/Graphics/UI/Gtk/WebKit/DOM/Enums.hs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/Enums.hs @@ -0,0 +1,312 @@ +module Graphics.UI.Gtk.WebKit.DOM.Enums( +DomEnum(..), +KeyType(..), +DomEnum, +KeyUsage(..), +CanvasWindingRule(..), +VideoPresentationMode(..), +TextTrackMode(..), +TextTrackKind(..), +DeviceType(..), +MediaUIPartID(..), +EndOfStreamError(..), +AppendMode(..), +SourceTypeEnum(..), +VideoFacingModeEnum(..), +MediaStreamTrackState(..), +RTCIceTransportsEnum(..), +RTCIdentityOptionEnum(..), +ReadableStreamStateType(..), +OverSampleType(..), +PageOverlayType(..), +XMLHttpRequestResponseType(..), +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures + + +class DomEnum e where + + enumToString :: e -> String + + stringToEnum :: String -> e + +data KeyType = KeyTypeSecret + | KeyTypePublic + | KeyTypePrivate + deriving (Show, Read, Eq, Ord, Typeable) + +instance DomEnum KeyType where + enumToString KeyTypeSecret = "secret" + enumToString KeyTypePublic = "public" + enumToString KeyTypePrivate = "private" + stringToEnum "secret" = KeyTypeSecret + stringToEnum "public" = KeyTypePublic + stringToEnum "private" = KeyTypePrivate + +data KeyUsage = KeyUsageEncrypt + | KeyUsageDecrypt + | KeyUsageSign + | KeyUsageVerify + | KeyUsageDeriveKey + | KeyUsageDeriveBits + | KeyUsageWrapKey + | KeyUsageUnwrapKey + deriving (Show, Read, Eq, Ord, Typeable) + +instance DomEnum KeyUsage where + enumToString KeyUsageEncrypt = "encrypt" + enumToString KeyUsageDecrypt = "decrypt" + enumToString KeyUsageSign = "sign" + enumToString KeyUsageVerify = "verify" + enumToString KeyUsageDeriveKey = "deriveKey" + enumToString KeyUsageDeriveBits = "deriveBits" + enumToString KeyUsageWrapKey = "wrapKey" + enumToString KeyUsageUnwrapKey = "unwrapKey" + stringToEnum "encrypt" = KeyUsageEncrypt + stringToEnum "decrypt" = KeyUsageDecrypt + stringToEnum "sign" = KeyUsageSign + stringToEnum "verify" = KeyUsageVerify + stringToEnum "deriveKey" = KeyUsageDeriveKey + stringToEnum "deriveBits" = KeyUsageDeriveBits + stringToEnum "wrapKey" = KeyUsageWrapKey + stringToEnum "unwrapKey" = KeyUsageUnwrapKey + +data CanvasWindingRule = CanvasWindingRuleNonzero + | CanvasWindingRuleEvenodd + deriving (Show, Read, Eq, Ord, Typeable) + +instance DomEnum CanvasWindingRule where + enumToString CanvasWindingRuleNonzero = "nonzero" + enumToString CanvasWindingRuleEvenodd = "evenodd" + stringToEnum "nonzero" = CanvasWindingRuleNonzero + stringToEnum "evenodd" = CanvasWindingRuleEvenodd + +data VideoPresentationMode = VideoPresentationModeFullscreen + | VideoPresentationModeOptimized + | VideoPresentationModeInline + deriving (Show, Read, Eq, Ord, Typeable) + +instance DomEnum VideoPresentationMode where + enumToString VideoPresentationModeFullscreen = "fullscreen" + enumToString VideoPresentationModeOptimized = "optimized" + enumToString VideoPresentationModeInline = "inline" + stringToEnum "fullscreen" = VideoPresentationModeFullscreen + stringToEnum "optimized" = VideoPresentationModeOptimized + stringToEnum "inline" = VideoPresentationModeInline + +data TextTrackMode = TextTrackModeDisabled + | TextTrackModeHidden + | TextTrackModeShowing + deriving (Show, Read, Eq, Ord, Typeable) + +instance DomEnum TextTrackMode where + enumToString TextTrackModeDisabled = "disabled" + enumToString TextTrackModeHidden = "hidden" + enumToString TextTrackModeShowing = "showing" + stringToEnum "disabled" = TextTrackModeDisabled + stringToEnum "hidden" = TextTrackModeHidden + stringToEnum "showing" = TextTrackModeShowing + +data TextTrackKind = TextTrackKindSubtitles + | TextTrackKindCaptions + | TextTrackKindDescriptions + | TextTrackKindChapters + | TextTrackKindMetadata + deriving (Show, Read, Eq, Ord, Typeable) + +instance DomEnum TextTrackKind where + enumToString TextTrackKindSubtitles = "subtitles" + enumToString TextTrackKindCaptions = "captions" + enumToString TextTrackKindDescriptions = "descriptions" + enumToString TextTrackKindChapters = "chapters" + enumToString TextTrackKindMetadata = "metadata" + stringToEnum "subtitles" = TextTrackKindSubtitles + stringToEnum "captions" = TextTrackKindCaptions + stringToEnum "descriptions" = TextTrackKindDescriptions + stringToEnum "chapters" = TextTrackKindChapters + stringToEnum "metadata" = TextTrackKindMetadata + +data DeviceType = DeviceTypeNone + | DeviceTypeAirplay + | DeviceTypeTvout + deriving (Show, Read, Eq, Ord, Typeable) + +instance DomEnum DeviceType where + enumToString DeviceTypeNone = "none" + enumToString DeviceTypeAirplay = "airplay" + enumToString DeviceTypeTvout = "tvout" + stringToEnum "none" = DeviceTypeNone + stringToEnum "airplay" = DeviceTypeAirplay + stringToEnum "tvout" = DeviceTypeTvout + +data MediaUIPartID = MediaUIPartIDOptimizedFullscreenButton + | MediaUIPartIDOptimizedFullscreenPlaceholder + deriving (Show, Read, Eq, Ord, Typeable) + +instance DomEnum MediaUIPartID where + enumToString MediaUIPartIDOptimizedFullscreenButton + = "optimized-fullscreen-button" + enumToString MediaUIPartIDOptimizedFullscreenPlaceholder + = "optimized-fullscreen-placeholder" + stringToEnum "optimized-fullscreen-button" + = MediaUIPartIDOptimizedFullscreenButton + stringToEnum "optimized-fullscreen-placeholder" + = MediaUIPartIDOptimizedFullscreenPlaceholder + +data EndOfStreamError = EndOfStreamErrorNetwork + | EndOfStreamErrorDecode + deriving (Show, Read, Eq, Ord, Typeable) + +instance DomEnum EndOfStreamError where + enumToString EndOfStreamErrorNetwork = "network" + enumToString EndOfStreamErrorDecode = "decode" + stringToEnum "network" = EndOfStreamErrorNetwork + stringToEnum "decode" = EndOfStreamErrorDecode + +data AppendMode = AppendModeSegments + | AppendModeSequence + deriving (Show, Read, Eq, Ord, Typeable) + +instance DomEnum AppendMode where + enumToString AppendModeSegments = "segments" + enumToString AppendModeSequence = "sequence" + stringToEnum "segments" = AppendModeSegments + stringToEnum "sequence" = AppendModeSequence + +data SourceTypeEnum = SourceTypeEnumNone + | SourceTypeEnumCamera + | SourceTypeEnumMicrophone + deriving (Show, Read, Eq, Ord, Typeable) + +instance DomEnum SourceTypeEnum where + enumToString SourceTypeEnumNone = "none" + enumToString SourceTypeEnumCamera = "camera" + enumToString SourceTypeEnumMicrophone = "microphone" + stringToEnum "none" = SourceTypeEnumNone + stringToEnum "camera" = SourceTypeEnumCamera + stringToEnum "microphone" = SourceTypeEnumMicrophone + +data VideoFacingModeEnum = VideoFacingModeEnumUser + | VideoFacingModeEnumEnvironment + | VideoFacingModeEnumLeft + | VideoFacingModeEnumRight + deriving (Show, Read, Eq, Ord, Typeable) + +instance DomEnum VideoFacingModeEnum where + enumToString VideoFacingModeEnumUser = "user" + enumToString VideoFacingModeEnumEnvironment = "environment" + enumToString VideoFacingModeEnumLeft = "left" + enumToString VideoFacingModeEnumRight = "right" + stringToEnum "user" = VideoFacingModeEnumUser + stringToEnum "environment" = VideoFacingModeEnumEnvironment + stringToEnum "left" = VideoFacingModeEnumLeft + stringToEnum "right" = VideoFacingModeEnumRight + +data MediaStreamTrackState = MediaStreamTrackStateNew + | MediaStreamTrackStateLive + | MediaStreamTrackStateEnded + deriving (Show, Read, Eq, Ord, Typeable) + +instance DomEnum MediaStreamTrackState where + enumToString MediaStreamTrackStateNew = "new" + enumToString MediaStreamTrackStateLive = "live" + enumToString MediaStreamTrackStateEnded = "ended" + stringToEnum "new" = MediaStreamTrackStateNew + stringToEnum "live" = MediaStreamTrackStateLive + stringToEnum "ended" = MediaStreamTrackStateEnded + +data RTCIceTransportsEnum = RTCIceTransportsEnumNone + | RTCIceTransportsEnumRelay + | RTCIceTransportsEnumAll + deriving (Show, Read, Eq, Ord, Typeable) + +instance DomEnum RTCIceTransportsEnum where + enumToString RTCIceTransportsEnumNone = "none" + enumToString RTCIceTransportsEnumRelay = "relay" + enumToString RTCIceTransportsEnumAll = "all" + stringToEnum "none" = RTCIceTransportsEnumNone + stringToEnum "relay" = RTCIceTransportsEnumRelay + stringToEnum "all" = RTCIceTransportsEnumAll + +data RTCIdentityOptionEnum = RTCIdentityOptionEnumYes + | RTCIdentityOptionEnumNo + | RTCIdentityOptionEnumIfconfigured + deriving (Show, Read, Eq, Ord, Typeable) + +instance DomEnum RTCIdentityOptionEnum where + enumToString RTCIdentityOptionEnumYes = "yes" + enumToString RTCIdentityOptionEnumNo = "no" + enumToString RTCIdentityOptionEnumIfconfigured = "ifconfigured" + stringToEnum "yes" = RTCIdentityOptionEnumYes + stringToEnum "no" = RTCIdentityOptionEnumNo + stringToEnum "ifconfigured" = RTCIdentityOptionEnumIfconfigured + +data ReadableStreamStateType = ReadableStreamStateTypeReadable + | ReadableStreamStateTypeWaiting + | ReadableStreamStateTypeClosed + | ReadableStreamStateTypeErrored + deriving (Show, Read, Eq, Ord, Typeable) + +instance DomEnum ReadableStreamStateType where + enumToString ReadableStreamStateTypeReadable = "readable" + enumToString ReadableStreamStateTypeWaiting = "waiting" + enumToString ReadableStreamStateTypeClosed = "closed" + enumToString ReadableStreamStateTypeErrored = "errored" + stringToEnum "readable" = ReadableStreamStateTypeReadable + stringToEnum "waiting" = ReadableStreamStateTypeWaiting + stringToEnum "closed" = ReadableStreamStateTypeClosed + stringToEnum "errored" = ReadableStreamStateTypeErrored + +data OverSampleType = OverSampleTypeNone + | OverSampleType2x + | OverSampleType4x + deriving (Show, Read, Eq, Ord, Typeable) + +instance DomEnum OverSampleType where + enumToString OverSampleTypeNone = "none" + enumToString OverSampleType2x = "2x" + enumToString OverSampleType4x = "4x" + stringToEnum "none" = OverSampleTypeNone + stringToEnum "2x" = OverSampleType2x + stringToEnum "4x" = OverSampleType4x + +data PageOverlayType = PageOverlayTypeView + | PageOverlayTypeDocument + deriving (Show, Read, Eq, Ord, Typeable) + +instance DomEnum PageOverlayType where + enumToString PageOverlayTypeView = "view" + enumToString PageOverlayTypeDocument = "document" + stringToEnum "view" = PageOverlayTypeView + stringToEnum "document" = PageOverlayTypeDocument + +data XMLHttpRequestResponseType = XMLHttpRequestResponseType + | XMLHttpRequestResponseTypeArraybuffer + | XMLHttpRequestResponseTypeBlob + | XMLHttpRequestResponseTypeDocument + | XMLHttpRequestResponseTypeJson + | XMLHttpRequestResponseTypeText + deriving (Show, Read, Eq, Ord, Typeable) + +instance DomEnum XMLHttpRequestResponseType where + enumToString XMLHttpRequestResponseType = "" + enumToString XMLHttpRequestResponseTypeArraybuffer = "arraybuffer" + enumToString XMLHttpRequestResponseTypeBlob = "blob" + enumToString XMLHttpRequestResponseTypeDocument = "document" + enumToString XMLHttpRequestResponseTypeJson = "json" + enumToString XMLHttpRequestResponseTypeText = "text" + stringToEnum "" = XMLHttpRequestResponseType + stringToEnum "arraybuffer" = XMLHttpRequestResponseTypeArraybuffer + stringToEnum "blob" = XMLHttpRequestResponseTypeBlob + stringToEnum "document" = XMLHttpRequestResponseTypeDocument + stringToEnum "json" = XMLHttpRequestResponseTypeJson + stringToEnum "text" = XMLHttpRequestResponseTypeText diff --git a/Graphics/UI/Gtk/WebKit/DOM/Event.chs b/Graphics/UI/Gtk/WebKit/DOM/Event.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/Event.chs @@ -0,0 +1,183 @@ +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 + + +stopPropagation :: (MonadIO m, EventClass self) => self -> m () +stopPropagation self + = liftIO + ({# call webkit_dom_event_stop_propagation #} (toEvent self)) + +preventDefault :: (MonadIO m, EventClass self) => self -> m () +preventDefault self + = liftIO + ({# call webkit_dom_event_prevent_default #} (toEvent self)) + +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)) + +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 + +getTarget :: + (MonadIO m, EventClass self) => self -> m (Maybe EventTarget) +getTarget self + = liftIO + (maybeNull (makeNewGObject mkEventTarget) + ({# call webkit_dom_event_get_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))) + +getEventPhase :: (MonadIO m, EventClass self) => self -> m Word +getEventPhase self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_event_get_event_phase #} (toEvent self))) + +getBubbles :: (MonadIO m, EventClass self) => self -> m Bool +getBubbles self + = liftIO + (toBool <$> + ({# call webkit_dom_event_get_bubbles #} (toEvent self))) + +getCancelable :: (MonadIO m, EventClass self) => self -> m Bool +getCancelable self + = liftIO + (toBool <$> + ({# call webkit_dom_event_get_cancelable #} (toEvent self))) + +getTimeStamp :: (MonadIO m, EventClass self) => self -> m Word +getTimeStamp self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_event_get_time_stamp #} (toEvent self))) + +getDefaultPrevented :: + (MonadIO m, EventClass self) => self -> m Bool +getDefaultPrevented self + = liftIO + (toBool <$> + ({# call webkit_dom_event_get_default_prevented #} (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))) + +setReturnValue :: + (MonadIO m, EventClass self) => self -> Bool -> m () +setReturnValue self val + = liftIO + ({# call webkit_dom_event_set_return_value #} (toEvent self) + (fromBool val)) + +getReturnValue :: (MonadIO m, EventClass self) => self -> m Bool +getReturnValue self + = liftIO + (toBool <$> + ({# call webkit_dom_event_get_return_value #} (toEvent self))) + +setCancelBubble :: + (MonadIO m, EventClass self) => self -> Bool -> m () +setCancelBubble self val + = liftIO + ({# call webkit_dom_event_set_cancel_bubble #} (toEvent self) + (fromBool val)) + +getCancelBubble :: (MonadIO m, EventClass self) => self -> m Bool +getCancelBubble self + = liftIO + (toBool <$> + ({# call webkit_dom_event_get_cancel_bubble #} (toEvent self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/EventM.hs b/Graphics/UI/Gtk/WebKit/DOM/EventM.hs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/EventM.hs @@ -0,0 +1,274 @@ +module Graphics.UI.Gtk.WebKit.DOM.EventM +( + EventM (..) +, EventName (..) +, newListener +, addListener +, removeListener +, on +, event +, eventTarget +, eventCurrentTarget +, eventPhase +, bubbles +, cancelable +, timeStamp +, stopPropagation +, preventDefault +, defaultPrevented +, stopImmediatePropagation +, srcElement +, getCancelBubble +, cancelBubble +, getReturnValue +, returnValue +, uiView +, uiDetail +, uiKeyCode +, uiCharCode +, uiLayerX +, uiLayerY +, uiLayerXY +, uiPageX +, uiPageY +, uiPageXY +, uiWhich +, mouseScreenX +, mouseScreenY +, mouseScreenXY +, mouseClientX +, mouseClientY +, mouseClientXY +, mouseMovementX +, mouseMovementY +, mouseMovementXY +, mouseCtrlKey +, mouseShiftKey +, mouseAltKey +, mouseMetaKey +, mouseButton +, mouseRelatedTarget +, mouseOffsetX +, mouseOffsetY +, mouseOffsetXY +, mouseX +, mouseY +, mouseXY +, mouseFromElement +, mouseToElement +) +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) + +type EventM t e = ReaderT e IO + +newListener :: (EventClass e) => EventM t e () -> IO (SaferEventListener t e) +newListener f = SaferEventListener <$> eventListenerNew (runReaderT f) + +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 + +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 + +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) + +target :: (EventClass e, GObjectClass t) => EventM t e (Maybe t) +target = (fmap (unsafeCastGObject . toGObject)) <$> (ask >>= Event.getTarget) + +event :: EventM t e e +event = ask + +eventTarget :: EventClass e => EventM t e (Maybe EventTarget) +eventTarget = event >>= Event.getTarget + +eventCurrentTarget :: EventClass e => EventM t e (Maybe EventTarget) +eventCurrentTarget = event >>= Event.getCurrentTarget + +eventPhase :: EventClass e => EventM t e Word +eventPhase = event >>= Event.getEventPhase + +bubbles :: EventClass e => EventM t e Bool +bubbles = event >>= Event.getBubbles + +cancelable :: EventClass e => EventM t e Bool +cancelable = event >>= Event.getCancelable + +timeStamp :: EventClass e => EventM t e Word +timeStamp = event >>= Event.getTimeStamp + +stopPropagation :: EventClass e => EventM t e () +stopPropagation = event >>= Event.stopPropagation + +preventDefault :: EventClass e => EventM t e () +preventDefault = event >>= Event.preventDefault + +defaultPrevented :: EventClass e => EventM t e Bool +defaultPrevented = event >>= Event.getDefaultPrevented + +stopImmediatePropagation :: EventClass e => EventM t e () +stopImmediatePropagation = event >>= Event.stopImmediatePropagation + +srcElement :: EventClass e => EventM t e (Maybe EventTarget) +srcElement = event >>= Event.getSrcElement + +getCancelBubble :: EventClass e => EventM t e Bool +getCancelBubble = event >>= Event.getCancelBubble + +cancelBubble :: EventClass e => Bool -> EventM t e () +cancelBubble f = event >>= flip Event.setCancelBubble f + +getReturnValue :: EventClass e => EventM t e Bool +getReturnValue = event >>= Event.getReturnValue + +returnValue :: EventClass e => Bool -> EventM t e () +returnValue f = event >>= flip Event.setReturnValue f + +uiView :: UIEventClass e => EventM t e (Maybe Window) +uiView = event >>= UIEvent.getView + +uiDetail :: UIEventClass e => EventM t e Int +uiDetail = event >>= UIEvent.getDetail + +uiKeyCode :: UIEventClass e => EventM t e Int +uiKeyCode = event >>= UIEvent.getKeyCode + +uiCharCode :: UIEventClass e => EventM t e Int +uiCharCode = event >>= UIEvent.getCharCode + +uiLayerX :: UIEventClass e => EventM t e Int +uiLayerX = event >>= UIEvent.getLayerX + +uiLayerY :: UIEventClass e => EventM t e Int +uiLayerY = event >>= UIEvent.getLayerY + +uiLayerXY :: UIEventClass e => EventM t e (Int, Int) +uiLayerXY = do + e <- event + x <- UIEvent.getLayerX e + y <- UIEvent.getLayerY e + return (x, y) + +uiPageX :: UIEventClass e => EventM t e Int +uiPageX = event >>= UIEvent.getPageX + +uiPageY :: UIEventClass e => EventM t e Int +uiPageY = event >>= UIEvent.getPageY + +uiPageXY :: UIEventClass e => EventM t e (Int, Int) +uiPageXY = do + e <- event + x <- UIEvent.getPageX e + y <- UIEvent.getPageY e + return (x, y) + +uiWhich :: UIEventClass e => EventM t e Int +uiWhich = event >>= UIEvent.getWhich + +mouseScreenX :: MouseEventClass e => EventM t e Int +mouseScreenX = event >>= MouseEvent.getScreenX + +mouseScreenY :: MouseEventClass e => EventM t e Int +mouseScreenY = event >>= MouseEvent.getScreenY + +mouseScreenXY :: MouseEventClass e => EventM t e (Int, Int) +mouseScreenXY = do + e <- event + x <- MouseEvent.getScreenX e + y <- MouseEvent.getScreenY e + return (x, y) + +mouseClientX :: MouseEventClass e => EventM t e Int +mouseClientX = event >>= MouseEvent.getClientX + +mouseClientY :: MouseEventClass e => EventM t e Int +mouseClientY = event >>= MouseEvent.getClientY + +mouseClientXY :: MouseEventClass e => EventM t e (Int, Int) +mouseClientXY = do + e <- event + x <- MouseEvent.getClientX e + y <- MouseEvent.getClientY e + return (x, y) + +mouseMovementX :: MouseEventClass e => EventM t e Int +mouseMovementX = event >>= MouseEvent.getMovementX + +mouseMovementY :: MouseEventClass e => EventM t e Int +mouseMovementY = event >>= MouseEvent.getMovementY + +mouseMovementXY :: MouseEventClass e => EventM t e (Int, Int) +mouseMovementXY = do + e <- event + x <- MouseEvent.getMovementX e + y <- MouseEvent.getMovementY e + return (x, y) + +mouseCtrlKey :: MouseEventClass e => EventM t e Bool +mouseCtrlKey = event >>= MouseEvent.getCtrlKey + +mouseShiftKey :: MouseEventClass e => EventM t e Bool +mouseShiftKey = event >>= MouseEvent.getShiftKey + +mouseAltKey :: MouseEventClass e => EventM t e Bool +mouseAltKey = event >>= MouseEvent.getAltKey + +mouseMetaKey :: MouseEventClass e => EventM t e Bool +mouseMetaKey = event >>= MouseEvent.getMetaKey + +mouseButton :: MouseEventClass e => EventM t e Word +mouseButton = event >>= MouseEvent.getButton + +mouseRelatedTarget :: MouseEventClass e => EventM t e (Maybe EventTarget) +mouseRelatedTarget = event >>= MouseEvent.getRelatedTarget + +mouseOffsetX :: MouseEventClass e => EventM t e Int +mouseOffsetX = event >>= MouseEvent.getOffsetX + +mouseOffsetY :: MouseEventClass e => EventM t e Int +mouseOffsetY = event >>= MouseEvent.getOffsetY + +mouseOffsetXY :: MouseEventClass e => EventM t e (Int, Int) +mouseOffsetXY = do + e <- event + x <- MouseEvent.getOffsetX e + y <- MouseEvent.getOffsetY e + return (x, y) + +mouseX :: MouseEventClass e => EventM t e Int +mouseX = event >>= MouseEvent.getX + +mouseY :: MouseEventClass e => EventM t e Int +mouseY = event >>= MouseEvent.getY + +mouseXY :: MouseEventClass e => EventM t e (Int, Int) +mouseXY = do + e <- event + x <- MouseEvent.getX e + y <- MouseEvent.getY e + return (x, y) + +mouseFromElement :: MouseEventClass e => EventM t e (Maybe Node) +mouseFromElement = event >>= MouseEvent.getFromElement + +mouseToElement :: MouseEventClass e => EventM t e (Maybe Node) +mouseToElement = event >>= MouseEvent.getToElement + diff --git a/Graphics/UI/Gtk/WebKit/DOM/EventTarget.chs b/Graphics/UI/Gtk/WebKit/DOM/EventTarget.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/EventTarget.chs @@ -0,0 +1,75 @@ +module Graphics.UI.Gtk.WebKit.DOM.EventTarget( +addEventListener, +removeEventListener, +dispatchEvent, +EventTarget, +castToEventTarget, +gTypeEventTarget, +EventTargetClass, +toEventTarget, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + + +addEventListener :: + (MonadIO m, EventTargetClass self, EventListenerClass listener, + GlibString string) => + self -> string -> Maybe listener -> Bool -> m () +addEventListener self type' listener useCapture + = liftIO + (void $ + withUTFString type' $ + \ typePtr -> +#if !WEBKIT_CHECK_VERSION(2,4,0) + {# call webkit_dom_event_target_add_event_listener_closure #} +#else + {# call webkit_dom_event_target_add_event_listener_with_closure #} +#endif + (toEventTarget self) + typePtr + (maybe nullPtr (castPtr . unEventListener . toEventListener) + listener) + (fromBool useCapture)) + +removeEventListener :: + (MonadIO m, EventTargetClass self, EventListenerClass listener, + GlibString string) => + self -> string -> Maybe listener -> Bool -> m () +removeEventListener self type' listener useCapture + = liftIO + (void $ + withUTFString type' $ + \ typePtr -> +#if !WEBKIT_CHECK_VERSION(2,4,0) + {# call webkit_dom_event_target_remove_event_listener_closure #} +#else + {# call webkit_dom_event_target_remove_event_listener_with_closure #} +#endif + (toEventTarget self) + typePtr + (maybe nullPtr (castPtr . unEventListener . toEventListener) + listener) + (fromBool useCapture)) + +dispatchEvent :: + (MonadIO m, EventTargetClass self, EventClass event) => + self -> Maybe event -> m () +dispatchEvent self event + = liftIO . void $ + propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_event_target_dispatch_event #} + (toEventTarget self) + (maybe (Event nullForeignPtr) toEvent event) + errorPtr_ diff --git a/Graphics/UI/Gtk/WebKit/DOM/EventTargetClosures.chs b/Graphics/UI/Gtk/WebKit/DOM/EventTargetClosures.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/EventTargetClosures.chs @@ -0,0 +1,56 @@ +{-# LANGUAGE CPP #-} +{-# CFILES events.c #-} +module Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures + (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 +{#import Graphics.UI.Gtk.WebKit.Types#} +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) + +eventListenerNew :: EventClass event => (event -> IO ()) -> IO EventListener +eventListenerNew callback = do + sptr <- newStablePtr action + gclosurePtr <- gtk2hs_closure_new sptr + 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' -> + callback (unsafeCastGObject obj2') + +eventListenerNewAsync :: EventClass event => (event -> IO ()) -> IO EventListener +eventListenerNewAsync = eventListenerNew + +eventListenerNewSync :: EventClass event => (event -> IO ()) -> IO EventListener +eventListenerNewSync = eventListenerNew + +foreign import ccall unsafe "g_closure_unref" + g_closure_unref :: Ptr GClosure -> IO () + +eventListenerRelease :: EventListener -> IO () +eventListenerRelease (EventListener gclosurePtr _) = g_closure_unref gclosurePtr + diff --git a/Graphics/UI/Gtk/WebKit/DOM/File.chs b/Graphics/UI/Gtk/WebKit/DOM/File.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/File.chs @@ -0,0 +1,41 @@ +module Graphics.UI.Gtk.WebKit.DOM.File( +getName, +#if WEBKIT_CHECK_VERSION(99,0,0) +getLastModifiedDate, +#endif +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 +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + + +getName :: + (MonadIO m, FileClass self, GlibString string) => self -> m string +getName self + = liftIO + (({# call webkit_dom_file_get_name #} (toFile self)) >>= + readUTFString) + +#if WEBKIT_CHECK_VERSION(99,0,0) +getLastModifiedDate :: + (MonadIO m, FileClass self) => self -> m (Maybe Date) +getLastModifiedDate self + = liftIO + (maybeNull (makeNewGObject mkDate) + ({# call webkit_dom_file_get_last_modified_date #} (toFile self))) +#endif diff --git a/Graphics/UI/Gtk/WebKit/DOM/FileList.chs b/Graphics/UI/Gtk/WebKit/DOM/FileList.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/FileList.chs @@ -0,0 +1,37 @@ +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 + + +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))) + +getLength :: (MonadIO m, FileListClass self) => self -> m Word +getLength self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_file_list_get_length #} (toFileList self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/Geolocation.chs b/Graphics/UI/Gtk/WebKit/DOM/Geolocation.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/Geolocation.chs @@ -0,0 +1,29 @@ +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 + + +clearWatch :: + (MonadIO m, GeolocationClass self) => self -> Int -> m () +clearWatch self watchID + = liftIO + ({# call webkit_dom_geolocation_clear_watch #} (toGeolocation self) + (fromIntegral watchID)) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLAnchorElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLAnchorElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLAnchorElement.chs @@ -0,0 +1,490 @@ +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 + + +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) + +getCharset :: + (MonadIO m, HTMLAnchorElementClass self, GlibString string) => + self -> m string +getCharset self + = liftIO + (({# call webkit_dom_html_anchor_element_get_charset #} + (toHTMLAnchorElement self)) + >>= + readUTFString) + +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) + +getCoords :: + (MonadIO m, HTMLAnchorElementClass self, GlibString string) => + self -> m string +getCoords self + = liftIO + (({# call webkit_dom_html_anchor_element_get_coords #} + (toHTMLAnchorElement self)) + >>= + readUTFString) + +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) + +getDownload :: + (MonadIO m, HTMLAnchorElementClass self, GlibString string) => + self -> m string +getDownload self + = liftIO + (({# call webkit_dom_html_anchor_element_get_download #} + (toHTMLAnchorElement self)) + >>= + readUTFString) + +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) + +getHref :: + (MonadIO m, HTMLAnchorElementClass self, GlibString string) => + self -> m string +getHref self + = liftIO + (({# call webkit_dom_html_anchor_element_get_href #} + (toHTMLAnchorElement self)) + >>= + readUTFString) + +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) + +getHreflang :: + (MonadIO m, HTMLAnchorElementClass self, GlibString string) => + self -> m string +getHreflang self + = liftIO + (({# call webkit_dom_html_anchor_element_get_hreflang #} + (toHTMLAnchorElement self)) + >>= + readUTFString) + +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) + +getName :: + (MonadIO m, HTMLAnchorElementClass self, GlibString string) => + self -> m string +getName self + = liftIO + (({# call webkit_dom_html_anchor_element_get_name #} + (toHTMLAnchorElement self)) + >>= + readUTFString) + +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) + +getPing :: + (MonadIO m, HTMLAnchorElementClass self, GlibString string) => + self -> m string +getPing self + = liftIO + (({# call webkit_dom_html_anchor_element_get_ping #} + (toHTMLAnchorElement self)) + >>= + readUTFString) + +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) + +getRel :: + (MonadIO m, HTMLAnchorElementClass self, GlibString string) => + self -> m string +getRel self + = liftIO + (({# call webkit_dom_html_anchor_element_get_rel #} + (toHTMLAnchorElement self)) + >>= + readUTFString) + +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) + +getRev :: + (MonadIO m, HTMLAnchorElementClass self, GlibString string) => + self -> m string +getRev self + = liftIO + (({# call webkit_dom_html_anchor_element_get_rev #} + (toHTMLAnchorElement self)) + >>= + readUTFString) + +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) + +getShape :: + (MonadIO m, HTMLAnchorElementClass self, GlibString string) => + self -> m string +getShape self + = liftIO + (({# call webkit_dom_html_anchor_element_get_shape #} + (toHTMLAnchorElement self)) + >>= + readUTFString) + +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) + +getTarget :: + (MonadIO m, HTMLAnchorElementClass self, GlibString string) => + self -> m string +getTarget self + = liftIO + (({# call webkit_dom_html_anchor_element_get_target #} + (toHTMLAnchorElement self)) + >>= + readUTFString) + +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) + +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) + +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) + +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) + +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) + +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) + +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) + +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) + +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) + +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) + +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) + +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) + +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) + +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) + +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 + +getText :: + (MonadIO m, HTMLAnchorElementClass self, GlibString string) => + self -> m string +getText self + = liftIO + (({# call webkit_dom_html_anchor_element_get_text #} + (toHTMLAnchorElement self)) + >>= + readUTFString) + +#if WEBKIT_CHECK_VERSION(99,0,0) +getRelList :: + (MonadIO m, HTMLAnchorElementClass self) => + self -> m (Maybe DOMTokenList) +getRelList self + = liftIO + (maybeNull (makeNewGObject mkDOMTokenList) + ({# call webkit_dom_html_anchor_element_get_rel_list #} + (toHTMLAnchorElement self))) +#endif diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLAppletElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLAppletElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLAppletElement.chs @@ -0,0 +1,264 @@ +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 + + +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) + +getAlign :: + (MonadIO m, HTMLAppletElementClass self, GlibString string) => + self -> m string +getAlign self + = liftIO + (({# call webkit_dom_html_applet_element_get_align #} + (toHTMLAppletElement self)) + >>= + readUTFString) + +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) + +getAlt :: + (MonadIO m, HTMLAppletElementClass self, GlibString string) => + self -> m string +getAlt self + = liftIO + (({# call webkit_dom_html_applet_element_get_alt #} + (toHTMLAppletElement self)) + >>= + readUTFString) + +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) + +getArchive :: + (MonadIO m, HTMLAppletElementClass self, GlibString string) => + self -> m string +getArchive self + = liftIO + (({# call webkit_dom_html_applet_element_get_archive #} + (toHTMLAppletElement self)) + >>= + readUTFString) + +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) + +getCode :: + (MonadIO m, HTMLAppletElementClass self, GlibString string) => + self -> m string +getCode self + = liftIO + (({# call webkit_dom_html_applet_element_get_code #} + (toHTMLAppletElement self)) + >>= + readUTFString) + +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) + +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) + +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) + +getHeight :: + (MonadIO m, HTMLAppletElementClass self, GlibString string) => + self -> m string +getHeight self + = liftIO + (({# call webkit_dom_html_applet_element_get_height #} + (toHTMLAppletElement self)) + >>= + readUTFString) + +setHspace :: + (MonadIO m, HTMLAppletElementClass self) => self -> Int -> m () +setHspace self val + = liftIO + ({# call webkit_dom_html_applet_element_set_hspace #} + (toHTMLAppletElement self) + (fromIntegral val)) + +getHspace :: + (MonadIO m, HTMLAppletElementClass self) => self -> m Int +getHspace self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_applet_element_get_hspace #} + (toHTMLAppletElement self))) + +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) + +getName :: + (MonadIO m, HTMLAppletElementClass self, GlibString string) => + self -> m string +getName self + = liftIO + (({# call webkit_dom_html_applet_element_get_name #} + (toHTMLAppletElement self)) + >>= + readUTFString) + +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) + +getObject :: + (MonadIO m, HTMLAppletElementClass self, GlibString string) => + self -> m string +getObject self + = liftIO + (({# call webkit_dom_html_applet_element_get_object #} + (toHTMLAppletElement self)) + >>= + readUTFString) + +setVspace :: + (MonadIO m, HTMLAppletElementClass self) => self -> Int -> m () +setVspace self val + = liftIO + ({# call webkit_dom_html_applet_element_set_vspace #} + (toHTMLAppletElement self) + (fromIntegral val)) + +getVspace :: + (MonadIO m, HTMLAppletElementClass self) => self -> m Int +getVspace self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_applet_element_get_vspace #} + (toHTMLAppletElement self))) + +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) + +getWidth :: + (MonadIO m, HTMLAppletElementClass self, GlibString string) => + self -> m string +getWidth self + = liftIO + (({# call webkit_dom_html_applet_element_get_width #} + (toHTMLAppletElement self)) + >>= + readUTFString) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLAreaElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLAreaElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLAreaElement.chs @@ -0,0 +1,295 @@ +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 + + +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) + +getAlt :: + (MonadIO m, HTMLAreaElementClass self, GlibString string) => + self -> m string +getAlt self + = liftIO + (({# call webkit_dom_html_area_element_get_alt #} + (toHTMLAreaElement self)) + >>= + readUTFString) + +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) + +getCoords :: + (MonadIO m, HTMLAreaElementClass self, GlibString string) => + self -> m string +getCoords self + = liftIO + (({# call webkit_dom_html_area_element_get_coords #} + (toHTMLAreaElement self)) + >>= + readUTFString) + +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) + +getHref :: + (MonadIO m, HTMLAreaElementClass self, GlibString string) => + self -> m string +getHref self + = liftIO + (({# call webkit_dom_html_area_element_get_href #} + (toHTMLAreaElement self)) + >>= + readUTFString) + +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)) + +getNoHref :: + (MonadIO m, HTMLAreaElementClass self) => self -> m Bool +getNoHref self + = liftIO + (toBool <$> + ({# call webkit_dom_html_area_element_get_no_href #} + (toHTMLAreaElement self))) + +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) + +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) + +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 + +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) + +getShape :: + (MonadIO m, HTMLAreaElementClass self, GlibString string) => + self -> m string +getShape self + = liftIO + (({# call webkit_dom_html_area_element_get_shape #} + (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) + +getTarget :: + (MonadIO m, HTMLAreaElementClass self, GlibString string) => + self -> m string +getTarget self + = liftIO + (({# call webkit_dom_html_area_element_get_target #} + (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) + +getHost :: + (MonadIO m, HTMLAreaElementClass self, GlibString string) => + self -> m string +getHost self + = liftIO + (({# call webkit_dom_html_area_element_get_host #} + (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) + +getPathname :: + (MonadIO m, HTMLAreaElementClass self, GlibString string) => + self -> m string +getPathname self + = liftIO + (({# call webkit_dom_html_area_element_get_pathname #} + (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) + +getProtocol :: + (MonadIO m, HTMLAreaElementClass self, GlibString string) => + self -> m string +getProtocol self + = liftIO + (({# call webkit_dom_html_area_element_get_protocol #} + (toHTMLAreaElement self)) + >>= + readUTFString) + +getSearch :: + (MonadIO m, HTMLAreaElementClass self, GlibString string) => + self -> m string +getSearch self + = liftIO + (({# call webkit_dom_html_area_element_get_search #} + (toHTMLAreaElement self)) + >>= + readUTFString) + +#if WEBKIT_CHECK_VERSION(99,0,0) +getRelList :: + (MonadIO m, HTMLAreaElementClass self) => + self -> m (Maybe DOMTokenList) +getRelList self + = liftIO + (maybeNull (makeNewGObject mkDOMTokenList) + ({# call webkit_dom_html_area_element_get_rel_list #} + (toHTMLAreaElement self))) +#endif diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLBRElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLBRElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLBRElement.chs @@ -0,0 +1,44 @@ +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 + + +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) + +getClear :: + (MonadIO m, HTMLBRElementClass self, GlibString string) => + self -> m string +getClear self + = liftIO + (({# call webkit_dom_htmlbr_element_get_clear #} + (toHTMLBRElement self)) + >>= + readUTFString) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLBaseElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLBaseElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLBaseElement.chs @@ -0,0 +1,67 @@ +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 + + +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) + +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) + +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) + +getTarget :: + (MonadIO m, HTMLBaseElementClass self, GlibString string) => + self -> m string +getTarget self + = liftIO + (({# call webkit_dom_html_base_element_get_target #} + (toHTMLBaseElement self)) + >>= + readUTFString) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLBaseFontElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLBaseFontElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLBaseFontElement.chs @@ -0,0 +1,85 @@ +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 + + +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) + +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) + +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) + +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) + +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)) + +getSize :: + (MonadIO m, HTMLBaseFontElementClass self) => self -> m Int +getSize self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_base_font_element_get_size #} + (toHTMLBaseFontElement self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLBodyElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLBodyElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLBodyElement.chs @@ -0,0 +1,216 @@ +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 + + +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) + +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) + +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) + +getBackground :: + (MonadIO m, HTMLBodyElementClass self, GlibString string) => + self -> m string +getBackground self + = liftIO + (({# call webkit_dom_html_body_element_get_background #} + (toHTMLBodyElement self)) + >>= + readUTFString) + +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) + +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) + +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) + +getLink :: + (MonadIO m, HTMLBodyElementClass self, GlibString string) => + self -> m string +getLink self + = liftIO + (({# call webkit_dom_html_body_element_get_link #} + (toHTMLBodyElement self)) + >>= + readUTFString) + +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) + +getText :: + (MonadIO m, HTMLBodyElementClass self, GlibString string) => + self -> m string +getText self + = liftIO + (({# call webkit_dom_html_body_element_get_text #} + (toHTMLBodyElement self)) + >>= + readUTFString) + +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) + +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) + +beforeUnload :: (HTMLBodyElementClass self) => EventName self Event +beforeUnload = EventName "beforeunload" + +hashChange :: (HTMLBodyElementClass self) => EventName self Event +hashChange = EventName "hashchange" + +message :: (HTMLBodyElementClass self) => EventName self Event +message = EventName "message" + +offline :: (HTMLBodyElementClass self) => EventName self Event +offline = EventName "offline" + +online :: (HTMLBodyElementClass self) => EventName self Event +online = EventName "online" + +popState :: (HTMLBodyElementClass self) => EventName self Event +popState = EventName "popstate" + +resize :: (HTMLBodyElementClass self) => EventName self UIEvent +resize = EventName "resize" + +storage :: (HTMLBodyElementClass self) => EventName self Event +storage = EventName "storage" + +unload :: (HTMLBodyElementClass self) => EventName self UIEvent +unload = EventName "unload" + +orientationChange :: + (HTMLBodyElementClass self) => EventName self Event +orientationChange = EventName "orientationchange" + +blur :: (HTMLBodyElementClass self) => EventName self UIEvent +blur = EventName "blur" + +error :: (HTMLBodyElementClass self) => EventName self UIEvent +error = EventName "error" + +focus :: (HTMLBodyElementClass self) => EventName self UIEvent +focus = EventName "focus" + +load :: (HTMLBodyElementClass self) => EventName self UIEvent +load = EventName "load" diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLButtonElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLButtonElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLButtonElement.chs @@ -0,0 +1,284 @@ +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 + + +checkValidity :: + (MonadIO m, HTMLButtonElementClass self) => self -> m Bool +checkValidity self + = liftIO + (toBool <$> + ({# call webkit_dom_html_button_element_check_validity #} + (toHTMLButtonElement self))) + +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) + +setAutofocus :: + (MonadIO m, HTMLButtonElementClass self) => self -> Bool -> m () +setAutofocus self val + = liftIO + ({# call webkit_dom_html_button_element_set_autofocus #} + (toHTMLButtonElement self) + (fromBool val)) + +getAutofocus :: + (MonadIO m, HTMLButtonElementClass self) => self -> m Bool +getAutofocus self + = liftIO + (toBool <$> + ({# call webkit_dom_html_button_element_get_autofocus #} + (toHTMLButtonElement self))) + +setDisabled :: + (MonadIO m, HTMLButtonElementClass self) => self -> Bool -> m () +setDisabled self val + = liftIO + ({# call webkit_dom_html_button_element_set_disabled #} + (toHTMLButtonElement self) + (fromBool val)) + +getDisabled :: + (MonadIO m, HTMLButtonElementClass self) => self -> m Bool +getDisabled self + = liftIO + (toBool <$> + ({# call webkit_dom_html_button_element_get_disabled #} + (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))) + +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) + +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) + +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) + +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) + +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) + +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) + +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)) + +getFormNoValidate :: + (MonadIO m, HTMLButtonElementClass self) => self -> m Bool +getFormNoValidate self + = liftIO + (toBool <$> + ({# call webkit_dom_html_button_element_get_form_no_validate #} + (toHTMLButtonElement self))) + +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) + +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) + +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) + +getName :: + (MonadIO m, HTMLButtonElementClass self, GlibString string) => + self -> m string +getName self + = liftIO + (({# call webkit_dom_html_button_element_get_name #} + (toHTMLButtonElement self)) + >>= + readUTFString) + +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) + +getValue :: + (MonadIO m, HTMLButtonElementClass self, GlibString string) => + self -> m string +getValue self + = liftIO + (({# call webkit_dom_html_button_element_get_value #} + (toHTMLButtonElement self)) + >>= + readUTFString) + +getWillValidate :: + (MonadIO m, HTMLButtonElementClass self) => self -> m Bool +getWillValidate self + = liftIO + (toBool <$> + ({# call webkit_dom_html_button_element_get_will_validate #} + (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))) + +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) + +getLabels :: + (MonadIO m, HTMLButtonElementClass self) => + self -> m (Maybe NodeList) +getLabels self + = liftIO + (maybeNull (makeNewGObject mkNodeList) + ({# call webkit_dom_html_button_element_get_labels #} + (toHTMLButtonElement self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLCanvasElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLCanvasElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLCanvasElement.chs @@ -0,0 +1,57 @@ +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 + + +setWidth :: + (MonadIO m, HTMLCanvasElementClass self) => self -> Int -> m () +setWidth self val + = liftIO + ({# call webkit_dom_html_canvas_element_set_width #} + (toHTMLCanvasElement self) + (fromIntegral val)) + +getWidth :: + (MonadIO m, HTMLCanvasElementClass self) => self -> m Int +getWidth self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_canvas_element_get_width #} + (toHTMLCanvasElement self))) + +setHeight :: + (MonadIO m, HTMLCanvasElementClass self) => self -> Int -> m () +setHeight self val + = liftIO + ({# call webkit_dom_html_canvas_element_set_height #} + (toHTMLCanvasElement self) + (fromIntegral val)) + +getHeight :: + (MonadIO m, HTMLCanvasElementClass self) => self -> m Int +getHeight self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_canvas_element_get_height #} + (toHTMLCanvasElement self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLCollection.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLCollection.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLCollection.chs @@ -0,0 +1,53 @@ +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 + + +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))) + +namedItem :: + (MonadIO m, HTMLCollectionClass self, GlibString string) => + self -> string -> m (Maybe Node) +namedItem self name + = liftIO + (maybeNull (makeNewGObject mkNode) + (withUTFString name $ + \ namePtr -> + {# call webkit_dom_html_collection_named_item #} + (toHTMLCollection self) + namePtr)) + +getLength :: + (MonadIO m, HTMLCollectionClass self) => self -> m Word +getLength self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_collection_get_length #} + (toHTMLCollection self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLDListElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLDListElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLDListElement.chs @@ -0,0 +1,39 @@ +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 + + +setCompact :: + (MonadIO m, HTMLDListElementClass self) => self -> Bool -> m () +setCompact self val + = liftIO + ({# call webkit_dom_htmld_list_element_set_compact #} + (toHTMLDListElement self) + (fromBool val)) + +getCompact :: + (MonadIO m, HTMLDListElementClass self) => self -> m Bool +getCompact self + = liftIO + (toBool <$> + ({# call webkit_dom_htmld_list_element_get_compact #} + (toHTMLDListElement self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLDetailsElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLDetailsElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLDetailsElement.chs @@ -0,0 +1,39 @@ +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 + + +setOpen :: + (MonadIO m, HTMLDetailsElementClass self) => self -> Bool -> m () +setOpen self val + = liftIO + ({# call webkit_dom_html_details_element_set_open #} + (toHTMLDetailsElement self) + (fromBool val)) + +getOpen :: + (MonadIO m, HTMLDetailsElementClass self) => self -> m Bool +getOpen self + = liftIO + (toBool <$> + ({# call webkit_dom_html_details_element_get_open #} + (toHTMLDetailsElement self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLDirectoryElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLDirectoryElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLDirectoryElement.chs @@ -0,0 +1,39 @@ +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 + + +setCompact :: + (MonadIO m, HTMLDirectoryElementClass self) => self -> Bool -> m () +setCompact self val + = liftIO + ({# call webkit_dom_html_directory_element_set_compact #} + (toHTMLDirectoryElement self) + (fromBool val)) + +getCompact :: + (MonadIO m, HTMLDirectoryElementClass self) => self -> m Bool +getCompact self + = liftIO + (toBool <$> + ({# call webkit_dom_html_directory_element_get_compact #} + (toHTMLDirectoryElement self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLDivElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLDivElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLDivElement.chs @@ -0,0 +1,44 @@ +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 + + +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) + +getAlign :: + (MonadIO m, HTMLDivElementClass self, GlibString string) => + self -> m string +getAlign self + = liftIO + (({# call webkit_dom_html_div_element_get_align #} + (toHTMLDivElement self)) + >>= + readUTFString) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLDocument.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLDocument.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLDocument.chs @@ -0,0 +1,266 @@ +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 +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + + +close :: (MonadIO m, HTMLDocumentClass self) => self -> m () +close self + = liftIO + ({# call webkit_dom_html_document_close #} (toHTMLDocument self)) + +clear :: (MonadIO m, HTMLDocumentClass self) => self -> m () +clear self + = liftIO + ({# call webkit_dom_html_document_clear #} (toHTMLDocument self)) + +captureEvents :: + (MonadIO m, HTMLDocumentClass self) => self -> m () +captureEvents self + = liftIO + ({# call webkit_dom_html_document_capture_events #} + (toHTMLDocument self)) + +releaseEvents :: + (MonadIO m, HTMLDocumentClass self) => self -> m () +releaseEvents self + = liftIO + ({# call webkit_dom_html_document_release_events #} + (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))) + +getPlugins :: + (MonadIO m, HTMLDocumentClass self) => + self -> m (Maybe HTMLCollection) +getPlugins self + = liftIO + (maybeNull (makeNewGObject mkHTMLCollection) + ({# call webkit_dom_html_document_get_plugins #} + (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))) + +getWidth :: (MonadIO m, HTMLDocumentClass self) => self -> m Int +getWidth self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_document_get_width #} + (toHTMLDocument self))) + +getHeight :: (MonadIO m, HTMLDocumentClass self) => self -> m Int +getHeight self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_document_get_height #} + (toHTMLDocument self))) + +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) + +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) + +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) + +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) + +getCompatMode :: + (MonadIO m, HTMLDocumentClass self, GlibString string) => + self -> m string +getCompatMode self + = liftIO + (({# call webkit_dom_html_document_get_compat_mode #} + (toHTMLDocument self)) + >>= + readUTFString) + +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) + +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) + +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) + +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) + +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) + +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) + +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) + +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) + +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) + +getVlinkColor :: + (MonadIO m, HTMLDocumentClass self, GlibString string) => + self -> m (Maybe string) +getVlinkColor self + = liftIO + (({# call webkit_dom_html_document_get_vlink_color #} + (toHTMLDocument self)) + >>= + maybePeek readUTFString) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLElement.chs @@ -0,0 +1,375 @@ +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 + + +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 html $ + \ htmlPtr -> + withUTFString where' $ + \ wherePtr -> + {# call webkit_dom_html_element_insert_adjacent_html #} + (toHTMLElement self) + wherePtr + htmlPtr + errorPtr_) + +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_) + +click :: (MonadIO m, HTMLElementClass self) => self -> m () +click self + = liftIO + ({# call webkit_dom_html_element_click #} (toHTMLElement self)) + +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) + +getTitle :: + (MonadIO m, HTMLElementClass self, GlibString string) => + self -> m string +getTitle self + = liftIO + (({# call webkit_dom_html_element_get_title #} + (toHTMLElement self)) + >>= + readUTFString) + +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) + +getLang :: + (MonadIO m, HTMLElementClass self, GlibString string) => + self -> m string +getLang self + = liftIO + (({# call webkit_dom_html_element_get_lang #} (toHTMLElement self)) + >>= + readUTFString) + +setTranslate :: + (MonadIO m, HTMLElementClass self) => self -> Bool -> m () +setTranslate self val + = liftIO + ({# call webkit_dom_html_element_set_translate #} + (toHTMLElement self) + (fromBool val)) + +getTranslate :: + (MonadIO m, HTMLElementClass self) => self -> m Bool +getTranslate self + = liftIO + (toBool <$> + ({# call webkit_dom_html_element_get_translate #} + (toHTMLElement self))) + +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) + +getDir :: + (MonadIO m, HTMLElementClass self, GlibString string) => + self -> m string +getDir self + = liftIO + (({# call webkit_dom_html_element_get_dir #} (toHTMLElement self)) + >>= + readUTFString) + +setTabIndex :: + (MonadIO m, HTMLElementClass self) => self -> Int -> m () +setTabIndex self val + = liftIO + ({# call webkit_dom_html_element_set_tab_index #} + (toHTMLElement self) + (fromIntegral val)) + +getTabIndex :: (MonadIO m, HTMLElementClass self) => self -> m Int +getTabIndex self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_element_get_tab_index #} + (toHTMLElement self))) + +setDraggable :: + (MonadIO m, HTMLElementClass self) => self -> Bool -> m () +setDraggable self val + = liftIO + ({# call webkit_dom_html_element_set_draggable #} + (toHTMLElement self) + (fromBool val)) + +getDraggable :: + (MonadIO m, HTMLElementClass self) => self -> m Bool +getDraggable self + = liftIO + (toBool <$> + ({# call webkit_dom_html_element_get_draggable #} + (toHTMLElement self))) + +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) + +getWebkitdropzone :: + (MonadIO m, HTMLElementClass self, GlibString string) => + self -> m string +getWebkitdropzone self + = liftIO + (({# call webkit_dom_html_element_get_webkitdropzone #} + (toHTMLElement self)) + >>= + readUTFString) + +setHidden :: + (MonadIO m, HTMLElementClass self) => self -> Bool -> m () +setHidden self val + = liftIO + ({# call webkit_dom_html_element_set_hidden #} (toHTMLElement self) + (fromBool val)) + +getHidden :: (MonadIO m, HTMLElementClass self) => self -> m Bool +getHidden self + = liftIO + (toBool <$> + ({# call webkit_dom_html_element_get_hidden #} + (toHTMLElement self))) + +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) + +getAccessKey :: + (MonadIO m, HTMLElementClass self, GlibString string) => + self -> m string +getAccessKey self + = liftIO + (({# call webkit_dom_html_element_get_access_key #} + (toHTMLElement self)) + >>= + readUTFString) + +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_) + +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) + +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_) + +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) + +getChildren :: + (MonadIO m, HTMLElementClass self) => + self -> m (Maybe HTMLCollection) +getChildren self + = liftIO + (maybeNull (makeNewGObject mkHTMLCollection) + ({# call webkit_dom_html_element_get_children #} + (toHTMLElement self))) + +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_) + +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) + +getIsContentEditable :: + (MonadIO m, HTMLElementClass self) => self -> m Bool +getIsContentEditable self + = liftIO + (toBool <$> + ({# call webkit_dom_html_element_get_is_content_editable #} + (toHTMLElement self))) + +setSpellcheck :: + (MonadIO m, HTMLElementClass self) => self -> Bool -> m () +setSpellcheck self val + = liftIO + ({# call webkit_dom_html_element_set_spellcheck #} + (toHTMLElement self) + (fromBool val)) + +getSpellcheck :: + (MonadIO m, HTMLElementClass self) => self -> m Bool +getSpellcheck self + = liftIO + (toBool <$> + ({# call webkit_dom_html_element_get_spellcheck #} + (toHTMLElement self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLEmbedElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLEmbedElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLEmbedElement.chs @@ -0,0 +1,126 @@ +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 + + +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) + +getAlign :: + (MonadIO m, HTMLEmbedElementClass self, GlibString string) => + self -> m string +getAlign self + = liftIO + (({# call webkit_dom_html_embed_element_get_align #} + (toHTMLEmbedElement self)) + >>= + readUTFString) + +setHeight :: + (MonadIO m, HTMLEmbedElementClass self) => self -> Int -> m () +setHeight self val + = liftIO + ({# call webkit_dom_html_embed_element_set_height #} + (toHTMLEmbedElement self) + (fromIntegral val)) + +getHeight :: + (MonadIO m, HTMLEmbedElementClass self) => self -> m Int +getHeight self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_embed_element_get_height #} + (toHTMLEmbedElement self))) + +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) + +getName :: + (MonadIO m, HTMLEmbedElementClass self, GlibString string) => + self -> m string +getName self + = liftIO + (({# call webkit_dom_html_embed_element_get_name #} + (toHTMLEmbedElement self)) + >>= + readUTFString) + +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) + +getSrc :: + (MonadIO m, HTMLEmbedElementClass self, GlibString string) => + self -> m string +getSrc self + = liftIO + (({# call webkit_dom_html_embed_element_get_src #} + (toHTMLEmbedElement self)) + >>= + readUTFString) + +setWidth :: + (MonadIO m, HTMLEmbedElementClass self) => self -> Int -> m () +setWidth self val + = liftIO + ({# call webkit_dom_html_embed_element_set_width #} + (toHTMLEmbedElement self) + (fromIntegral val)) + +getWidth :: + (MonadIO m, HTMLEmbedElementClass self) => self -> m Int +getWidth self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_embed_element_get_width #} + (toHTMLEmbedElement self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLFieldSetElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLFieldSetElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLFieldSetElement.chs @@ -0,0 +1,142 @@ +module Graphics.UI.Gtk.WebKit.DOM.HTMLFieldSetElement( +checkValidity, +setCustomValidity, +#if WEBKIT_CHECK_VERSION(2,2,2) +setDisabled, +getDisabled, +#endif +getForm, +#if WEBKIT_CHECK_VERSION(2,2,2) +setName, +getName, +getElements, +#endif +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 +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + + +checkValidity :: + (MonadIO m, HTMLFieldSetElementClass self) => self -> m Bool +checkValidity self + = liftIO + (toBool <$> + ({# call webkit_dom_html_field_set_element_check_validity #} + (toHTMLFieldSetElement self))) + +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)) + +getDisabled :: + (MonadIO m, HTMLFieldSetElementClass self) => self -> m Bool +getDisabled self + = liftIO + (toBool <$> + ({# call webkit_dom_html_field_set_element_get_disabled #} + (toHTMLFieldSetElement self))) +#endif + +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) + +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) + +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 + +getWillValidate :: + (MonadIO m, HTMLFieldSetElementClass self) => self -> m Bool +getWillValidate self + = liftIO + (toBool <$> + ({# call webkit_dom_html_field_set_element_get_will_validate #} + (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))) + +getValidationMessage :: + (MonadIO m, HTMLFieldSetElementClass self, GlibString string) => + self -> m string +getValidationMessage self + = liftIO + (({# call webkit_dom_html_field_set_element_get_validation_message + #} + (toHTMLFieldSetElement self)) + >>= + readUTFString) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLFontElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLFontElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLFontElement.chs @@ -0,0 +1,90 @@ +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 + + +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) + +getColor :: + (MonadIO m, HTMLFontElementClass self, GlibString string) => + self -> m string +getColor self + = liftIO + (({# call webkit_dom_html_font_element_get_color #} + (toHTMLFontElement self)) + >>= + readUTFString) + +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) + +getFace :: + (MonadIO m, HTMLFontElementClass self, GlibString string) => + self -> m string +getFace self + = liftIO + (({# call webkit_dom_html_font_element_get_face #} + (toHTMLFontElement self)) + >>= + readUTFString) + +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) + +getSize :: + (MonadIO m, HTMLFontElementClass self, GlibString string) => + self -> m string +getSize self + = liftIO + (({# call webkit_dom_html_font_element_get_size #} + (toHTMLFontElement self)) + >>= + readUTFString) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLFormElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLFormElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLFormElement.chs @@ -0,0 +1,331 @@ +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 + + +submit :: (MonadIO m, HTMLFormElementClass self) => self -> m () +submit self + = liftIO + ({# call webkit_dom_html_form_element_submit #} + (toHTMLFormElement self)) + +reset :: (MonadIO m, HTMLFormElementClass self) => self -> m () +reset self + = liftIO + ({# call webkit_dom_html_form_element_reset #} + (toHTMLFormElement self)) + +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 + +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) + +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) + +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) + +getAction :: + (MonadIO m, HTMLFormElementClass self, GlibString string) => + self -> m string +getAction self + = liftIO + (({# call webkit_dom_html_form_element_get_action #} + (toHTMLFormElement self)) + >>= + readUTFString) + +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) + +getAutocomplete :: + (MonadIO m, HTMLFormElementClass self, GlibString string) => + self -> m string +getAutocomplete self + = liftIO + (({# call webkit_dom_html_form_element_get_autocomplete #} + (toHTMLFormElement self)) + >>= + readUTFString) + +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) + +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) + +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) + +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) + +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) + +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) + +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) + +getName :: + (MonadIO m, HTMLFormElementClass self, GlibString string) => + self -> m string +getName self + = liftIO + (({# call webkit_dom_html_form_element_get_name #} + (toHTMLFormElement self)) + >>= + readUTFString) + +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)) + +getNoValidate :: + (MonadIO m, HTMLFormElementClass self) => self -> m Bool +getNoValidate self + = liftIO + (toBool <$> + ({# call webkit_dom_html_form_element_get_no_validate #} + (toHTMLFormElement self))) + +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) + +getTarget :: + (MonadIO m, HTMLFormElementClass self, GlibString string) => + self -> m string +getTarget self + = liftIO + (({# call webkit_dom_html_form_element_get_target #} + (toHTMLFormElement self)) + >>= + readUTFString) + +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))) + +getLength :: + (MonadIO m, HTMLFormElementClass self) => self -> m Int +getLength self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_form_element_get_length #} + (toHTMLFormElement self))) + +#if WEBKIT_CHECK_VERSION(2,4,0) +setAutocorrect :: + (MonadIO m, HTMLFormElementClass self) => self -> Bool -> m () +setAutocorrect self val + = liftIO + ({# call webkit_dom_html_form_element_set_autocorrect #} + (toHTMLFormElement self) + (fromBool val)) + +getAutocorrect :: + (MonadIO m, HTMLFormElementClass self) => self -> m Bool +getAutocorrect self + = liftIO + (toBool <$> + ({# call webkit_dom_html_form_element_get_autocorrect #} + (toHTMLFormElement self))) + +setAutocapitalize :: + (MonadIO m, HTMLFormElementClass self, GlibString string) => + self -> (Maybe string) -> m () +setAutocapitalize self val + = liftIO + (maybeWith withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_form_element_set_autocapitalize #} + (toHTMLFormElement self) + valPtr) + +getAutocapitalize :: + (MonadIO m, HTMLFormElementClass self, GlibString string) => + self -> m (Maybe string) +getAutocapitalize self + = liftIO + (({# call webkit_dom_html_form_element_get_autocapitalize #} + (toHTMLFormElement self)) + >>= + maybePeek readUTFString) +#endif + +autocomplete :: (HTMLFormElementClass self) => EventName self Event +autocomplete = EventName "autocomplete" + +autocompleteerror :: + (HTMLFormElementClass self) => EventName self Event +autocompleteerror = EventName "autocompleteerror" diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLFrameElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLFrameElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLFrameElement.chs @@ -0,0 +1,237 @@ +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 + + +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) + +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) + +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) + +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) + +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) + +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) + +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) + +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) + +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) + +getName :: + (MonadIO m, HTMLFrameElementClass self, GlibString string) => + self -> m string +getName self + = liftIO + (({# call webkit_dom_html_frame_element_get_name #} + (toHTMLFrameElement self)) + >>= + readUTFString) + +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)) + +getNoResize :: + (MonadIO m, HTMLFrameElementClass self) => self -> m Bool +getNoResize self + = liftIO + (toBool <$> + ({# call webkit_dom_html_frame_element_get_no_resize #} + (toHTMLFrameElement self))) + +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) + +getScrolling :: + (MonadIO m, HTMLFrameElementClass self, GlibString string) => + self -> m string +getScrolling self + = liftIO + (({# call webkit_dom_html_frame_element_get_scrolling #} + (toHTMLFrameElement self)) + >>= + readUTFString) + +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) + +getSrc :: + (MonadIO m, HTMLFrameElementClass self, GlibString string) => + self -> m string +getSrc self + = liftIO + (({# call webkit_dom_html_frame_element_get_src #} + (toHTMLFrameElement self)) + >>= + readUTFString) + +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))) + +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))) + +getWidth :: + (MonadIO m, HTMLFrameElementClass self) => self -> m Int +getWidth self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_frame_element_get_width #} + (toHTMLFrameElement self))) + +getHeight :: + (MonadIO m, HTMLFrameElementClass self) => self -> m Int +getHeight self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_frame_element_get_height #} + (toHTMLFrameElement self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLFrameSetElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLFrameSetElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLFrameSetElement.chs @@ -0,0 +1,126 @@ +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 + + +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) + +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) + +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) + +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) + +beforeUnload :: + (HTMLFrameSetElementClass self) => EventName self Event +beforeUnload = EventName "beforeunload" + +hashChange :: + (HTMLFrameSetElementClass self) => EventName self Event +hashChange = EventName "hashchange" + +message :: (HTMLFrameSetElementClass self) => EventName self Event +message = EventName "message" + +offline :: (HTMLFrameSetElementClass self) => EventName self Event +offline = EventName "offline" + +online :: (HTMLFrameSetElementClass self) => EventName self Event +online = EventName "online" + +popState :: (HTMLFrameSetElementClass self) => EventName self Event +popState = EventName "popstate" + +resize :: (HTMLFrameSetElementClass self) => EventName self UIEvent +resize = EventName "resize" + +storage :: (HTMLFrameSetElementClass self) => EventName self Event +storage = EventName "storage" + +unload :: (HTMLFrameSetElementClass self) => EventName self UIEvent +unload = EventName "unload" + +orientationChange :: + (HTMLFrameSetElementClass self) => EventName self Event +orientationChange = EventName "orientationchange" + +blur :: (HTMLFrameSetElementClass self) => EventName self UIEvent +blur = EventName "blur" + +error :: (HTMLFrameSetElementClass self) => EventName self UIEvent +error = EventName "error" + +focus :: (HTMLFrameSetElementClass self) => EventName self UIEvent +focus = EventName "focus" + +load :: (HTMLFrameSetElementClass self) => EventName self UIEvent +load = EventName "load" diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLHRElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLHRElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLHRElement.chs @@ -0,0 +1,108 @@ +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 + + +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) + +getAlign :: + (MonadIO m, HTMLHRElementClass self, GlibString string) => + self -> m string +getAlign self + = liftIO + (({# call webkit_dom_htmlhr_element_get_align #} + (toHTMLHRElement self)) + >>= + readUTFString) + +setNoShade :: + (MonadIO m, HTMLHRElementClass self) => self -> Bool -> m () +setNoShade self val + = liftIO + ({# call webkit_dom_htmlhr_element_set_no_shade #} + (toHTMLHRElement self) + (fromBool val)) + +getNoShade :: + (MonadIO m, HTMLHRElementClass self) => self -> m Bool +getNoShade self + = liftIO + (toBool <$> + ({# call webkit_dom_htmlhr_element_get_no_shade #} + (toHTMLHRElement self))) + +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) + +getSize :: + (MonadIO m, HTMLHRElementClass self, GlibString string) => + self -> m string +getSize self + = liftIO + (({# call webkit_dom_htmlhr_element_get_size #} + (toHTMLHRElement self)) + >>= + readUTFString) + +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) + +getWidth :: + (MonadIO m, HTMLHRElementClass self, GlibString string) => + self -> m string +getWidth self + = liftIO + (({# call webkit_dom_htmlhr_element_get_width #} + (toHTMLHRElement self)) + >>= + readUTFString) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLHeadElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLHeadElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLHeadElement.chs @@ -0,0 +1,44 @@ +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 + + +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) + +getProfile :: + (MonadIO m, HTMLHeadElementClass self, GlibString string) => + self -> m string +getProfile self + = liftIO + (({# call webkit_dom_html_head_element_get_profile #} + (toHTMLHeadElement self)) + >>= + readUTFString) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLHeadingElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLHeadingElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLHeadingElement.chs @@ -0,0 +1,44 @@ +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 + + +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) + +getAlign :: + (MonadIO m, HTMLHeadingElementClass self, GlibString string) => + self -> m string +getAlign self + = liftIO + (({# call webkit_dom_html_heading_element_get_align #} + (toHTMLHeadingElement self)) + >>= + readUTFString) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLHtmlElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLHtmlElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLHtmlElement.chs @@ -0,0 +1,67 @@ +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 + + +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) + +getVersion :: + (MonadIO m, HTMLHtmlElementClass self, GlibString string) => + self -> m string +getVersion self + = liftIO + (({# call webkit_dom_html_html_element_get_version #} + (toHTMLHtmlElement self)) + >>= + readUTFString) + +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) + +getManifest :: + (MonadIO m, HTMLHtmlElementClass self, GlibString string) => + self -> m string +getManifest self + = liftIO + (({# call webkit_dom_html_html_element_get_manifest #} + (toHTMLHtmlElement self)) + >>= + readUTFString) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLIFrameElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLIFrameElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLIFrameElement.chs @@ -0,0 +1,321 @@ +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 +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 +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + + +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) + +getAlign :: + (MonadIO m, HTMLIFrameElementClass self, GlibString string) => + self -> m string +getAlign self + = liftIO + (({# call webkit_dom_html_iframe_element_get_align #} + (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) + +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) + +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) + +getHeight :: + (MonadIO m, HTMLIFrameElementClass self, GlibString string) => + self -> m string +getHeight self + = liftIO + (({# call webkit_dom_html_iframe_element_get_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) + +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) + +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) + +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) + +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) + +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) + +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) + +getName :: + (MonadIO m, HTMLIFrameElementClass self, GlibString string) => + self -> m string +getName self + = liftIO + (({# call webkit_dom_html_iframe_element_get_name #} + (toHTMLIFrameElement self)) + >>= + readUTFString) + +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) + +getSandbox :: + (MonadIO m, HTMLIFrameElementClass self, GlibString string) => + self -> m string +getSandbox self + = liftIO + (({# call webkit_dom_html_iframe_element_get_sandbox #} + (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) + +getScrolling :: + (MonadIO m, HTMLIFrameElementClass self, GlibString string) => + self -> m string +getScrolling self + = liftIO + (({# call webkit_dom_html_iframe_element_get_scrolling #} + (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) + +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) + +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 + +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) + +getWidth :: + (MonadIO m, HTMLIFrameElementClass self, GlibString string) => + self -> m string +getWidth self + = liftIO + (({# call webkit_dom_html_iframe_element_get_width #} + (toHTMLIFrameElement self)) + >>= + readUTFString) + +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))) + +getContentWindow :: + (MonadIO m, HTMLIFrameElementClass self) => + self -> m (Maybe Window) +getContentWindow self + = liftIO + (maybeNull (makeNewGObject mkWindow) + ({# call webkit_dom_html_iframe_element_get_content_window #} + (toHTMLIFrameElement self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLImageElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLImageElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLImageElement.chs @@ -0,0 +1,426 @@ +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) +setSrcset, +getSrcset, +#endif +#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 +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + + +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) + +getName :: + (MonadIO m, HTMLImageElementClass self, GlibString string) => + self -> m string +getName self + = liftIO + (({# call webkit_dom_html_image_element_get_name #} + (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) + +getAlign :: + (MonadIO m, HTMLImageElementClass self, GlibString string) => + self -> m string +getAlign self + = liftIO + (({# call webkit_dom_html_image_element_get_align #} + (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) + +getAlt :: + (MonadIO m, HTMLImageElementClass self, GlibString string) => + self -> m string +getAlt self + = liftIO + (({# call webkit_dom_html_image_element_get_alt #} + (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) + +getBorder :: + (MonadIO m, HTMLImageElementClass self, GlibString string) => + self -> m string +getBorder self + = liftIO + (({# call webkit_dom_html_image_element_get_border #} + (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) + +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) + +setHeight :: + (MonadIO m, HTMLImageElementClass self) => self -> Int -> m () +setHeight self val + = liftIO + ({# call webkit_dom_html_image_element_set_height #} + (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))) + +setHspace :: + (MonadIO m, HTMLImageElementClass self) => self -> Int -> m () +setHspace self val + = liftIO + ({# call webkit_dom_html_image_element_set_hspace #} + (toHTMLImageElement self) + (fromIntegral val)) + +getHspace :: + (MonadIO m, HTMLImageElementClass self) => self -> m Int +getHspace self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_image_element_get_hspace #} + (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)) + +getIsMap :: + (MonadIO m, HTMLImageElementClass self) => self -> m Bool +getIsMap self + = liftIO + (toBool <$> + ({# call webkit_dom_html_image_element_get_is_map #} + (toHTMLImageElement self))) + +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) + +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) + +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) + +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) + +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 + +#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) + +getSizes :: + (MonadIO m, HTMLImageElementClass self, GlibString string) => + self -> m string +getSizes self + = liftIO + (({# call webkit_dom_html_image_element_get_sizes #} + (toHTMLImageElement self)) + >>= + readUTFString) + +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 + +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) + +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) + +setVspace :: + (MonadIO m, HTMLImageElementClass self) => self -> Int -> m () +setVspace self val + = liftIO + ({# call webkit_dom_html_image_element_set_vspace #} + (toHTMLImageElement self) + (fromIntegral val)) + +getVspace :: + (MonadIO m, HTMLImageElementClass self) => self -> m Int +getVspace self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_image_element_get_vspace #} + (toHTMLImageElement self))) + +setWidth :: + (MonadIO m, HTMLImageElementClass self) => self -> Int -> m () +setWidth self val + = liftIO + ({# call webkit_dom_html_image_element_set_width #} + (toHTMLImageElement self) + (fromIntegral val)) + +getWidth :: + (MonadIO m, HTMLImageElementClass self) => self -> m Int +getWidth self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_image_element_get_width #} + (toHTMLImageElement self))) + +getComplete :: + (MonadIO m, HTMLImageElementClass self) => self -> m Bool +getComplete self + = liftIO + (toBool <$> + ({# call webkit_dom_html_image_element_get_complete #} + (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) + +getLowsrc :: + (MonadIO m, HTMLImageElementClass self, GlibString string) => + self -> m string +getLowsrc self + = liftIO + (({# call webkit_dom_html_image_element_get_lowsrc #} + (toHTMLImageElement self)) + >>= + readUTFString) + +getNaturalHeight :: + (MonadIO m, HTMLImageElementClass self) => self -> m Int +getNaturalHeight self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_image_element_get_natural_height #} + (toHTMLImageElement self))) + +getNaturalWidth :: + (MonadIO m, HTMLImageElementClass self) => self -> m Int +getNaturalWidth self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_image_element_get_natural_width #} + (toHTMLImageElement self))) + +getX :: (MonadIO m, HTMLImageElementClass self) => self -> m Int +getX self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_image_element_get_x #} + (toHTMLImageElement self))) + +getY :: (MonadIO m, HTMLImageElementClass self) => self -> m Int +getY self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_image_element_get_y #} + (toHTMLImageElement self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLInputElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLInputElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLInputElement.chs @@ -0,0 +1,988 @@ +module Graphics.UI.Gtk.WebKit.DOM.HTMLInputElement( +stepUp, +stepDown, +checkValidity, +setCustomValidity, +select, +#if WEBKIT_CHECK_VERSION(2,2,2) +setRangeText4, +#endif +setValueForUser, +setAccept, +getAccept, +setAlt, +getAlt, +setAutocomplete, +getAutocomplete, +setAutofocus, +getAutofocus, +setDefaultChecked, +getDefaultChecked, +setChecked, +getChecked, +setDirName, +getDirName, +setDisabled, +getDisabled, +getForm, +#if WEBKIT_CHECK_VERSION(2,2,2) +setFiles, +#endif +getFiles, +setFormAction, +getFormAction, +setFormEnctype, +getFormEnctype, +setFormMethod, +getFormMethod, +setFormNoValidate, +getFormNoValidate, +setFormTarget, +getFormTarget, +#if WEBKIT_CHECK_VERSION(2,2,2) +setHeight, +getHeight, +#endif +setIndeterminate, +getIndeterminate, +getList, +setMax, +getMax, +setMaxLength, +getMaxLength, +setMin, +getMin, +setMultiple, +getMultiple, +setName, +getName, +setPattern, +getPattern, +setPlaceholder, +getPlaceholder, +setReadOnly, +getReadOnly, +setRequired, +getRequired, +#if WEBKIT_CHECK_VERSION(2,2,2) +setSize, +#endif +getSize, +setSrc, +getSrc, +setStep, +getStep, +setDefaultValue, +getDefaultValue, +setValue, +getValue, +setValueAsNumber, +getValueAsNumber, +#if WEBKIT_CHECK_VERSION(2,2,2) +setWidth, +getWidth, +#endif +getWillValidate, +getValidity, +getValidationMessage, +getLabels, +setAlign, +getAlign, +setUseMap, +getUseMap, +setIncremental, +getIncremental, +#if WEBKIT_CHECK_VERSION(2,4,0) +setAutocorrect, +getAutocorrect, +setAutocapitalize, +getAutocapitalize, +#endif +#if WEBKIT_CHECK_VERSION(2,7,0) +setCapture, +getCapture, +#endif +HTMLInputElement, +castToHTMLInputElement, +gTypeHTMLInputElement, +HTMLInputElementClass, +toHTMLInputElement, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures +import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + + +stepUp :: + (MonadIO m, HTMLInputElementClass self) => self -> Int -> m () +stepUp self n + = liftIO + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_html_input_element_step_up #} + (toHTMLInputElement self) + (fromIntegral n) + errorPtr_) + +stepDown :: + (MonadIO m, HTMLInputElementClass self) => self -> Int -> m () +stepDown self n + = liftIO + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_html_input_element_step_down #} + (toHTMLInputElement self) + (fromIntegral n) + errorPtr_) + +checkValidity :: + (MonadIO m, HTMLInputElementClass self) => self -> m Bool +checkValidity self + = liftIO + (toBool <$> + ({# call webkit_dom_html_input_element_check_validity #} + (toHTMLInputElement self))) + +setCustomValidity :: + (MonadIO m, HTMLInputElementClass self, GlibString string) => + self -> (Maybe string) -> m () +setCustomValidity self error + = liftIO + (maybeWith withUTFString error $ + \ errorPtr -> + {# call webkit_dom_html_input_element_set_custom_validity #} + (toHTMLInputElement self) + errorPtr) + +select :: (MonadIO m, HTMLInputElementClass self) => self -> m () +select self + = liftIO + ({# call webkit_dom_html_input_element_select #} + (toHTMLInputElement self)) + +#if WEBKIT_CHECK_VERSION(2,2,2) +setRangeText4 :: + (MonadIO m, HTMLInputElementClass self, GlibString string) => + self -> string -> Word -> Word -> string -> m () +setRangeText4 self replacement start end selectionMode + = liftIO + (propagateGError $ + \ errorPtr_ -> + withUTFString selectionMode $ + \ selectionModePtr -> + withUTFString replacement $ + \ replacementPtr -> + {# call webkit_dom_html_input_element_set_range_text #} + (toHTMLInputElement self) + replacementPtr + (fromIntegral start) + (fromIntegral end) + selectionModePtr + errorPtr_) +#endif + +setValueForUser :: + (MonadIO m, HTMLInputElementClass self, GlibString string) => + self -> (Maybe string) -> m () +setValueForUser self value + = liftIO + (maybeWith withUTFString value $ + \ valuePtr -> + {# call webkit_dom_html_input_element_set_value_for_user #} + (toHTMLInputElement self) + valuePtr) + +setAccept :: + (MonadIO m, HTMLInputElementClass self, GlibString string) => + self -> string -> m () +setAccept self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_input_element_set_accept #} + (toHTMLInputElement self) + valPtr) + +getAccept :: + (MonadIO m, HTMLInputElementClass self, GlibString string) => + self -> m string +getAccept self + = liftIO + (({# call webkit_dom_html_input_element_get_accept #} + (toHTMLInputElement self)) + >>= + readUTFString) + +setAlt :: + (MonadIO m, HTMLInputElementClass self, GlibString string) => + self -> string -> m () +setAlt self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_input_element_set_alt #} + (toHTMLInputElement self) + valPtr) + +getAlt :: + (MonadIO m, HTMLInputElementClass self, GlibString string) => + self -> m string +getAlt self + = liftIO + (({# call webkit_dom_html_input_element_get_alt #} + (toHTMLInputElement self)) + >>= + readUTFString) + +setAutocomplete :: + (MonadIO m, HTMLInputElementClass self, GlibString string) => + self -> string -> m () +setAutocomplete self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_input_element_set_autocomplete #} + (toHTMLInputElement self) + valPtr) + +getAutocomplete :: + (MonadIO m, HTMLInputElementClass self, GlibString string) => + self -> m string +getAutocomplete self + = liftIO + (({# call webkit_dom_html_input_element_get_autocomplete #} + (toHTMLInputElement self)) + >>= + readUTFString) + +setAutofocus :: + (MonadIO m, HTMLInputElementClass self) => self -> Bool -> m () +setAutofocus self val + = liftIO + ({# call webkit_dom_html_input_element_set_autofocus #} + (toHTMLInputElement self) + (fromBool val)) + +getAutofocus :: + (MonadIO m, HTMLInputElementClass self) => self -> m Bool +getAutofocus self + = liftIO + (toBool <$> + ({# call webkit_dom_html_input_element_get_autofocus #} + (toHTMLInputElement self))) + +setDefaultChecked :: + (MonadIO m, HTMLInputElementClass self) => self -> Bool -> m () +setDefaultChecked self val + = liftIO + ({# call webkit_dom_html_input_element_set_default_checked #} + (toHTMLInputElement self) + (fromBool val)) + +getDefaultChecked :: + (MonadIO m, HTMLInputElementClass self) => self -> m Bool +getDefaultChecked self + = liftIO + (toBool <$> + ({# call webkit_dom_html_input_element_get_default_checked #} + (toHTMLInputElement self))) + +setChecked :: + (MonadIO m, HTMLInputElementClass self) => self -> Bool -> m () +setChecked self val + = liftIO + ({# call webkit_dom_html_input_element_set_checked #} + (toHTMLInputElement self) + (fromBool val)) + +getChecked :: + (MonadIO m, HTMLInputElementClass self) => self -> m Bool +getChecked self + = liftIO + (toBool <$> + ({# call webkit_dom_html_input_element_get_checked #} + (toHTMLInputElement self))) + +setDirName :: + (MonadIO m, HTMLInputElementClass self, GlibString string) => + self -> string -> m () +setDirName self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_input_element_set_dir_name #} + (toHTMLInputElement self) + valPtr) + +getDirName :: + (MonadIO m, HTMLInputElementClass self, GlibString string) => + self -> m string +getDirName self + = liftIO + (({# call webkit_dom_html_input_element_get_dir_name #} + (toHTMLInputElement self)) + >>= + readUTFString) + +setDisabled :: + (MonadIO m, HTMLInputElementClass self) => self -> Bool -> m () +setDisabled self val + = liftIO + ({# call webkit_dom_html_input_element_set_disabled #} + (toHTMLInputElement self) + (fromBool val)) + +getDisabled :: + (MonadIO m, HTMLInputElementClass self) => self -> m Bool +getDisabled self + = liftIO + (toBool <$> + ({# call webkit_dom_html_input_element_get_disabled #} + (toHTMLInputElement self))) + +getForm :: + (MonadIO m, HTMLInputElementClass self) => + self -> m (Maybe HTMLFormElement) +getForm self + = liftIO + (maybeNull (makeNewGObject mkHTMLFormElement) + ({# call webkit_dom_html_input_element_get_form #} + (toHTMLInputElement self))) + +#if WEBKIT_CHECK_VERSION(2,2,2) +setFiles :: + (MonadIO m, FileListClass val, HTMLInputElementClass self) => + self -> Maybe val -> m () +setFiles self val + = liftIO + ({# call webkit_dom_html_input_element_set_files #} + (toHTMLInputElement self) + (maybe (FileList nullForeignPtr) toFileList val)) +#endif + +getFiles :: + (MonadIO m, HTMLInputElementClass self) => + self -> m (Maybe FileList) +getFiles self + = liftIO + (maybeNull (makeNewGObject mkFileList) + ({# call webkit_dom_html_input_element_get_files #} + (toHTMLInputElement self))) + +setFormAction :: + (MonadIO m, HTMLInputElementClass self, GlibString string) => + self -> string -> m () +setFormAction self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_input_element_set_form_action #} + (toHTMLInputElement self) + valPtr) + +getFormAction :: + (MonadIO m, HTMLInputElementClass self, GlibString string) => + self -> m string +getFormAction self + = liftIO + (({# call webkit_dom_html_input_element_get_form_action #} + (toHTMLInputElement self)) + >>= + readUTFString) + +setFormEnctype :: + (MonadIO m, HTMLInputElementClass self, GlibString string) => + self -> (Maybe string) -> m () +setFormEnctype self val + = liftIO + (maybeWith withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_input_element_set_form_enctype #} + (toHTMLInputElement self) + valPtr) + +getFormEnctype :: + (MonadIO m, HTMLInputElementClass self, GlibString string) => + self -> m (Maybe string) +getFormEnctype self + = liftIO + (({# call webkit_dom_html_input_element_get_form_enctype #} + (toHTMLInputElement self)) + >>= + maybePeek readUTFString) + +setFormMethod :: + (MonadIO m, HTMLInputElementClass self, GlibString string) => + self -> (Maybe string) -> m () +setFormMethod self val + = liftIO + (maybeWith withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_input_element_set_form_method #} + (toHTMLInputElement self) + valPtr) + +getFormMethod :: + (MonadIO m, HTMLInputElementClass self, GlibString string) => + self -> m (Maybe string) +getFormMethod self + = liftIO + (({# call webkit_dom_html_input_element_get_form_method #} + (toHTMLInputElement self)) + >>= + maybePeek readUTFString) + +setFormNoValidate :: + (MonadIO m, HTMLInputElementClass self) => self -> Bool -> m () +setFormNoValidate self val + = liftIO + ({# call webkit_dom_html_input_element_set_form_no_validate #} + (toHTMLInputElement self) + (fromBool val)) + +getFormNoValidate :: + (MonadIO m, HTMLInputElementClass self) => self -> m Bool +getFormNoValidate self + = liftIO + (toBool <$> + ({# call webkit_dom_html_input_element_get_form_no_validate #} + (toHTMLInputElement self))) + +setFormTarget :: + (MonadIO m, HTMLInputElementClass self, GlibString string) => + self -> string -> m () +setFormTarget self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_input_element_set_form_target #} + (toHTMLInputElement self) + valPtr) + +getFormTarget :: + (MonadIO m, HTMLInputElementClass self, GlibString string) => + self -> m string +getFormTarget self + = liftIO + (({# call webkit_dom_html_input_element_get_form_target #} + (toHTMLInputElement self)) + >>= + readUTFString) + +#if WEBKIT_CHECK_VERSION(2,2,2) +setHeight :: + (MonadIO m, HTMLInputElementClass self) => self -> Word -> m () +setHeight self val + = liftIO + ({# call webkit_dom_html_input_element_set_height #} + (toHTMLInputElement self) + (fromIntegral val)) + +getHeight :: + (MonadIO m, HTMLInputElementClass self) => self -> m Word +getHeight self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_input_element_get_height #} + (toHTMLInputElement self))) +#endif + +setIndeterminate :: + (MonadIO m, HTMLInputElementClass self) => self -> Bool -> m () +setIndeterminate self val + = liftIO + ({# call webkit_dom_html_input_element_set_indeterminate #} + (toHTMLInputElement self) + (fromBool val)) + +getIndeterminate :: + (MonadIO m, HTMLInputElementClass self) => self -> m Bool +getIndeterminate self + = liftIO + (toBool <$> + ({# call webkit_dom_html_input_element_get_indeterminate #} + (toHTMLInputElement self))) + +getList :: + (MonadIO m, HTMLInputElementClass self) => + self -> m (Maybe HTMLElement) +getList self + = liftIO + (maybeNull (makeNewGObject mkHTMLElement) + ({# call webkit_dom_html_input_element_get_list #} + (toHTMLInputElement self))) + +setMax :: + (MonadIO m, HTMLInputElementClass self, GlibString string) => + self -> string -> m () +setMax self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_input_element_set_max #} + (toHTMLInputElement self) + valPtr) + +getMax :: + (MonadIO m, HTMLInputElementClass self, GlibString string) => + self -> m string +getMax self + = liftIO + (({# call webkit_dom_html_input_element_get_max #} + (toHTMLInputElement self)) + >>= + readUTFString) + +setMaxLength :: + (MonadIO m, HTMLInputElementClass self) => self -> Int -> m () +setMaxLength self val + = liftIO + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_html_input_element_set_max_length #} + (toHTMLInputElement self) + (fromIntegral val) + errorPtr_) + +getMaxLength :: + (MonadIO m, HTMLInputElementClass self) => self -> m Int +getMaxLength self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_input_element_get_max_length #} + (toHTMLInputElement self))) + +setMin :: + (MonadIO m, HTMLInputElementClass self, GlibString string) => + self -> string -> m () +setMin self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_input_element_set_min #} + (toHTMLInputElement self) + valPtr) + +getMin :: + (MonadIO m, HTMLInputElementClass self, GlibString string) => + self -> m string +getMin self + = liftIO + (({# call webkit_dom_html_input_element_get_min #} + (toHTMLInputElement self)) + >>= + readUTFString) + +setMultiple :: + (MonadIO m, HTMLInputElementClass self) => self -> Bool -> m () +setMultiple self val + = liftIO + ({# call webkit_dom_html_input_element_set_multiple #} + (toHTMLInputElement self) + (fromBool val)) + +getMultiple :: + (MonadIO m, HTMLInputElementClass self) => self -> m Bool +getMultiple self + = liftIO + (toBool <$> + ({# call webkit_dom_html_input_element_get_multiple #} + (toHTMLInputElement self))) + +setName :: + (MonadIO m, HTMLInputElementClass self, GlibString string) => + self -> string -> m () +setName self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_input_element_set_name #} + (toHTMLInputElement self) + valPtr) + +getName :: + (MonadIO m, HTMLInputElementClass self, GlibString string) => + self -> m string +getName self + = liftIO + (({# call webkit_dom_html_input_element_get_name #} + (toHTMLInputElement self)) + >>= + readUTFString) + +setPattern :: + (MonadIO m, HTMLInputElementClass self, GlibString string) => + self -> string -> m () +setPattern self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_input_element_set_pattern #} + (toHTMLInputElement self) + valPtr) + +getPattern :: + (MonadIO m, HTMLInputElementClass self, GlibString string) => + self -> m string +getPattern self + = liftIO + (({# call webkit_dom_html_input_element_get_pattern #} + (toHTMLInputElement self)) + >>= + readUTFString) + +setPlaceholder :: + (MonadIO m, HTMLInputElementClass self, GlibString string) => + self -> string -> m () +setPlaceholder self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_input_element_set_placeholder #} + (toHTMLInputElement self) + valPtr) + +getPlaceholder :: + (MonadIO m, HTMLInputElementClass self, GlibString string) => + self -> m string +getPlaceholder self + = liftIO + (({# call webkit_dom_html_input_element_get_placeholder #} + (toHTMLInputElement self)) + >>= + readUTFString) + +setReadOnly :: + (MonadIO m, HTMLInputElementClass self) => self -> Bool -> m () +setReadOnly self val + = liftIO + ({# call webkit_dom_html_input_element_set_read_only #} + (toHTMLInputElement self) + (fromBool val)) + +getReadOnly :: + (MonadIO m, HTMLInputElementClass self) => self -> m Bool +getReadOnly self + = liftIO + (toBool <$> + ({# call webkit_dom_html_input_element_get_read_only #} + (toHTMLInputElement self))) + +setRequired :: + (MonadIO m, HTMLInputElementClass self) => self -> Bool -> m () +setRequired self val + = liftIO + ({# call webkit_dom_html_input_element_set_required #} + (toHTMLInputElement self) + (fromBool val)) + +getRequired :: + (MonadIO m, HTMLInputElementClass self) => self -> m Bool +getRequired self + = liftIO + (toBool <$> + ({# call webkit_dom_html_input_element_get_required #} + (toHTMLInputElement self))) + +#if WEBKIT_CHECK_VERSION(2,2,2) +setSize :: + (MonadIO m, HTMLInputElementClass self) => self -> Word -> m () +setSize self val + = liftIO + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_html_input_element_set_size #} + (toHTMLInputElement self) + (fromIntegral val) + errorPtr_) +#endif + +getSize :: + (MonadIO m, HTMLInputElementClass self) => self -> m Word +getSize self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_input_element_get_size #} + (toHTMLInputElement self))) + +setSrc :: + (MonadIO m, HTMLInputElementClass self, GlibString string) => + self -> string -> m () +setSrc self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_input_element_set_src #} + (toHTMLInputElement self) + valPtr) + +getSrc :: + (MonadIO m, HTMLInputElementClass self, GlibString string) => + self -> m string +getSrc self + = liftIO + (({# call webkit_dom_html_input_element_get_src #} + (toHTMLInputElement self)) + >>= + readUTFString) + +setStep :: + (MonadIO m, HTMLInputElementClass self, GlibString string) => + self -> string -> m () +setStep self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_input_element_set_step #} + (toHTMLInputElement self) + valPtr) + +getStep :: + (MonadIO m, HTMLInputElementClass self, GlibString string) => + self -> m string +getStep self + = liftIO + (({# call webkit_dom_html_input_element_get_step #} + (toHTMLInputElement self)) + >>= + readUTFString) + +setDefaultValue :: + (MonadIO m, HTMLInputElementClass self, GlibString string) => + self -> (Maybe string) -> m () +setDefaultValue self val + = liftIO + (maybeWith withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_input_element_set_default_value #} + (toHTMLInputElement self) + valPtr) + +getDefaultValue :: + (MonadIO m, HTMLInputElementClass self, GlibString string) => + self -> m (Maybe string) +getDefaultValue self + = liftIO + (({# call webkit_dom_html_input_element_get_default_value #} + (toHTMLInputElement self)) + >>= + maybePeek readUTFString) + +setValue :: + (MonadIO m, HTMLInputElementClass self, GlibString string) => + self -> (Maybe string) -> m () +setValue self val + = liftIO + (maybeWith withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_input_element_set_value #} + (toHTMLInputElement self) + valPtr) + +getValue :: + (MonadIO m, HTMLInputElementClass self, GlibString string) => + self -> m (Maybe string) +getValue self + = liftIO + (({# call webkit_dom_html_input_element_get_value #} + (toHTMLInputElement self)) + >>= + maybePeek readUTFString) + +setValueAsNumber :: + (MonadIO m, HTMLInputElementClass self) => self -> Double -> m () +setValueAsNumber self val + = liftIO + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_html_input_element_set_value_as_number #} + (toHTMLInputElement self) + (realToFrac val) + errorPtr_) + +getValueAsNumber :: + (MonadIO m, HTMLInputElementClass self) => self -> m Double +getValueAsNumber self + = liftIO + (realToFrac <$> + ({# call webkit_dom_html_input_element_get_value_as_number #} + (toHTMLInputElement self))) + +#if WEBKIT_CHECK_VERSION(2,2,2) +setWidth :: + (MonadIO m, HTMLInputElementClass self) => self -> Word -> m () +setWidth self val + = liftIO + ({# call webkit_dom_html_input_element_set_width #} + (toHTMLInputElement self) + (fromIntegral val)) + +getWidth :: + (MonadIO m, HTMLInputElementClass self) => self -> m Word +getWidth self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_input_element_get_width #} + (toHTMLInputElement self))) +#endif + +getWillValidate :: + (MonadIO m, HTMLInputElementClass self) => self -> m Bool +getWillValidate self + = liftIO + (toBool <$> + ({# call webkit_dom_html_input_element_get_will_validate #} + (toHTMLInputElement self))) + +getValidity :: + (MonadIO m, HTMLInputElementClass self) => + self -> m (Maybe ValidityState) +getValidity self + = liftIO + (maybeNull (makeNewGObject mkValidityState) + ({# call webkit_dom_html_input_element_get_validity #} + (toHTMLInputElement self))) + +getValidationMessage :: + (MonadIO m, HTMLInputElementClass self, GlibString string) => + self -> m string +getValidationMessage self + = liftIO + (({# call webkit_dom_html_input_element_get_validation_message #} + (toHTMLInputElement self)) + >>= + readUTFString) + +getLabels :: + (MonadIO m, HTMLInputElementClass self) => + self -> m (Maybe NodeList) +getLabels self + = liftIO + (maybeNull (makeNewGObject mkNodeList) + ({# call webkit_dom_html_input_element_get_labels #} + (toHTMLInputElement self))) + +setAlign :: + (MonadIO m, HTMLInputElementClass self, GlibString string) => + self -> string -> m () +setAlign self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_input_element_set_align #} + (toHTMLInputElement self) + valPtr) + +getAlign :: + (MonadIO m, HTMLInputElementClass self, GlibString string) => + self -> m string +getAlign self + = liftIO + (({# call webkit_dom_html_input_element_get_align #} + (toHTMLInputElement self)) + >>= + readUTFString) + +setUseMap :: + (MonadIO m, HTMLInputElementClass self, GlibString string) => + self -> string -> m () +setUseMap self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_input_element_set_use_map #} + (toHTMLInputElement self) + valPtr) + +getUseMap :: + (MonadIO m, HTMLInputElementClass self, GlibString string) => + self -> m string +getUseMap self + = liftIO + (({# call webkit_dom_html_input_element_get_use_map #} + (toHTMLInputElement self)) + >>= + readUTFString) + +setIncremental :: + (MonadIO m, HTMLInputElementClass self) => self -> Bool -> m () +setIncremental self val + = liftIO + ({# call webkit_dom_html_input_element_set_incremental #} + (toHTMLInputElement self) + (fromBool val)) + +getIncremental :: + (MonadIO m, HTMLInputElementClass self) => self -> m Bool +getIncremental self + = liftIO + (toBool <$> + ({# call webkit_dom_html_input_element_get_incremental #} + (toHTMLInputElement self))) + +#if WEBKIT_CHECK_VERSION(2,4,0) +setAutocorrect :: + (MonadIO m, HTMLInputElementClass self) => self -> Bool -> m () +setAutocorrect self val + = liftIO + ({# call webkit_dom_html_input_element_set_autocorrect #} + (toHTMLInputElement self) + (fromBool val)) + +getAutocorrect :: + (MonadIO m, HTMLInputElementClass self) => self -> m Bool +getAutocorrect self + = liftIO + (toBool <$> + ({# call webkit_dom_html_input_element_get_autocorrect #} + (toHTMLInputElement self))) + +setAutocapitalize :: + (MonadIO m, HTMLInputElementClass self, GlibString string) => + self -> (Maybe string) -> m () +setAutocapitalize self val + = liftIO + (maybeWith withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_input_element_set_autocapitalize #} + (toHTMLInputElement self) + valPtr) + +getAutocapitalize :: + (MonadIO m, HTMLInputElementClass self, GlibString string) => + self -> m (Maybe string) +getAutocapitalize self + = liftIO + (({# call webkit_dom_html_input_element_get_autocapitalize #} + (toHTMLInputElement self)) + >>= + maybePeek readUTFString) +#endif + +#if WEBKIT_CHECK_VERSION(2,7,0) +setCapture :: + (MonadIO m, HTMLInputElementClass self) => self -> Bool -> m () +setCapture self val + = liftIO + ({# call webkit_dom_html_input_element_set_capture #} + (toHTMLInputElement self) + (fromBool val)) + +getCapture :: + (MonadIO m, HTMLInputElementClass self) => self -> m Bool +getCapture self + = liftIO + (toBool <$> + ({# call webkit_dom_html_input_element_get_capture #} + (toHTMLInputElement self))) +#endif diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLKeygenElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLKeygenElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLKeygenElement.chs @@ -0,0 +1,197 @@ +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 + + +checkValidity :: + (MonadIO m, HTMLKeygenElementClass self) => self -> m Bool +checkValidity self + = liftIO + (toBool <$> + ({# call webkit_dom_html_keygen_element_check_validity #} + (toHTMLKeygenElement self))) + +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) + +setAutofocus :: + (MonadIO m, HTMLKeygenElementClass self) => self -> Bool -> m () +setAutofocus self val + = liftIO + ({# call webkit_dom_html_keygen_element_set_autofocus #} + (toHTMLKeygenElement self) + (fromBool val)) + +getAutofocus :: + (MonadIO m, HTMLKeygenElementClass self) => self -> m Bool +getAutofocus self + = liftIO + (toBool <$> + ({# call webkit_dom_html_keygen_element_get_autofocus #} + (toHTMLKeygenElement self))) + +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) + +getChallenge :: + (MonadIO m, HTMLKeygenElementClass self, GlibString string) => + self -> m string +getChallenge self + = liftIO + (({# call webkit_dom_html_keygen_element_get_challenge #} + (toHTMLKeygenElement self)) + >>= + readUTFString) + +setDisabled :: + (MonadIO m, HTMLKeygenElementClass self) => self -> Bool -> m () +setDisabled self val + = liftIO + ({# call webkit_dom_html_keygen_element_set_disabled #} + (toHTMLKeygenElement self) + (fromBool val)) + +getDisabled :: + (MonadIO m, HTMLKeygenElementClass self) => self -> m Bool +getDisabled self + = liftIO + (toBool <$> + ({# call webkit_dom_html_keygen_element_get_disabled #} + (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))) + +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) + +getKeytype :: + (MonadIO m, HTMLKeygenElementClass self, GlibString string) => + self -> m string +getKeytype self + = liftIO + (({# call webkit_dom_html_keygen_element_get_keytype #} + (toHTMLKeygenElement self)) + >>= + readUTFString) + +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) + +getName :: + (MonadIO m, HTMLKeygenElementClass self, GlibString string) => + self -> m string +getName self + = liftIO + (({# call webkit_dom_html_keygen_element_get_name #} + (toHTMLKeygenElement self)) + >>= + readUTFString) + +getWillValidate :: + (MonadIO m, HTMLKeygenElementClass self) => self -> m Bool +getWillValidate self + = liftIO + (toBool <$> + ({# call webkit_dom_html_keygen_element_get_will_validate #} + (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))) + +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) + +getLabels :: + (MonadIO m, HTMLKeygenElementClass self) => + self -> m (Maybe NodeList) +getLabels self + = liftIO + (maybeNull (makeNewGObject mkNodeList) + ({# call webkit_dom_html_keygen_element_get_labels #} + (toHTMLKeygenElement self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLLIElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLLIElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLLIElement.chs @@ -0,0 +1,38 @@ +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 + + +setValue :: + (MonadIO m, HTMLLIElementClass self) => self -> Int -> m () +setValue self val + = liftIO + ({# call webkit_dom_htmlli_element_set_value #} + (toHTMLLIElement self) + (fromIntegral val)) + +getValue :: (MonadIO m, HTMLLIElementClass self) => self -> m Int +getValue self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_htmlli_element_get_value #} + (toHTMLLIElement self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLLabelElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLLabelElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLLabelElement.chs @@ -0,0 +1,64 @@ +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 + + +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))) + +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) + +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) + +getControl :: + (MonadIO m, HTMLLabelElementClass self) => + self -> m (Maybe HTMLElement) +getControl self + = liftIO + (maybeNull (makeNewGObject mkHTMLElement) + ({# call webkit_dom_html_label_element_get_control #} + (toHTMLLabelElement self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLLegendElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLLegendElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLLegendElement.chs @@ -0,0 +1,54 @@ +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 + + +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))) + +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) + +getAlign :: + (MonadIO m, HTMLLegendElementClass self, GlibString string) => + self -> m string +getAlign self + = liftIO + (({# call webkit_dom_html_legend_element_get_align #} + (toHTMLLegendElement self)) + >>= + readUTFString) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLLinkElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLLinkElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLLinkElement.chs @@ -0,0 +1,224 @@ +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 + + +setDisabled :: + (MonadIO m, HTMLLinkElementClass self) => self -> Bool -> m () +setDisabled self val + = liftIO + ({# call webkit_dom_html_link_element_set_disabled #} + (toHTMLLinkElement self) + (fromBool val)) + +getDisabled :: + (MonadIO m, HTMLLinkElementClass self) => self -> m Bool +getDisabled self + = liftIO + (toBool <$> + ({# call webkit_dom_html_link_element_get_disabled #} + (toHTMLLinkElement self))) + +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) + +getCharset :: + (MonadIO m, HTMLLinkElementClass self, GlibString string) => + self -> m string +getCharset self + = liftIO + (({# call webkit_dom_html_link_element_get_charset #} + (toHTMLLinkElement self)) + >>= + readUTFString) + +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) + +getHref :: + (MonadIO m, HTMLLinkElementClass self, GlibString string) => + self -> m string +getHref self + = liftIO + (({# call webkit_dom_html_link_element_get_href #} + (toHTMLLinkElement self)) + >>= + readUTFString) + +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) + +getHreflang :: + (MonadIO m, HTMLLinkElementClass self, GlibString string) => + self -> m string +getHreflang self + = liftIO + (({# call webkit_dom_html_link_element_get_hreflang #} + (toHTMLLinkElement self)) + >>= + readUTFString) + +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) + +getMedia :: + (MonadIO m, HTMLLinkElementClass self, GlibString string) => + self -> m string +getMedia self + = liftIO + (({# call webkit_dom_html_link_element_get_media #} + (toHTMLLinkElement self)) + >>= + readUTFString) + +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) + +getRel :: + (MonadIO m, HTMLLinkElementClass self, GlibString string) => + self -> m string +getRel self + = liftIO + (({# call webkit_dom_html_link_element_get_rel #} + (toHTMLLinkElement self)) + >>= + readUTFString) + +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) + +getRev :: + (MonadIO m, HTMLLinkElementClass self, GlibString string) => + self -> m string +getRev self + = liftIO + (({# call webkit_dom_html_link_element_get_rev #} + (toHTMLLinkElement self)) + >>= + readUTFString) + +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) + +getTarget :: + (MonadIO m, HTMLLinkElementClass self, GlibString string) => + self -> m string +getTarget self + = liftIO + (({# call webkit_dom_html_link_element_get_target #} + (toHTMLLinkElement self)) + >>= + readUTFString) + +getSheet :: + (MonadIO m, HTMLLinkElementClass self) => + self -> m (Maybe StyleSheet) +getSheet self + = liftIO + (maybeNull (makeNewGObject mkStyleSheet) + ({# call webkit_dom_html_link_element_get_sheet #} + (toHTMLLinkElement self))) + +#if WEBKIT_CHECK_VERSION(99,0,0) +getRelList :: + (MonadIO m, HTMLLinkElementClass self) => + self -> m (Maybe DOMTokenList) +getRelList self + = liftIO + (maybeNull (makeNewGObject mkDOMTokenList) + ({# call webkit_dom_html_link_element_get_rel_list #} + (toHTMLLinkElement self))) +#endif diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLMapElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLMapElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLMapElement.chs @@ -0,0 +1,54 @@ +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 + + +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))) + +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) + +getName :: + (MonadIO m, HTMLMapElementClass self, GlibString string) => + self -> m string +getName self + = liftIO + (({# call webkit_dom_html_map_element_get_name #} + (toHTMLMapElement self)) + >>= + readUTFString) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLMarqueeElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLMarqueeElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLMarqueeElement.chs @@ -0,0 +1,267 @@ +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 + + +start :: (MonadIO m, HTMLMarqueeElementClass self) => self -> m () +start self + = liftIO + ({# call webkit_dom_html_marquee_element_start #} + (toHTMLMarqueeElement self)) + +stop :: (MonadIO m, HTMLMarqueeElementClass self) => self -> m () +stop self + = liftIO + ({# call webkit_dom_html_marquee_element_stop #} + (toHTMLMarqueeElement self)) + +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) + +getBehavior :: + (MonadIO m, HTMLMarqueeElementClass self, GlibString string) => + self -> m string +getBehavior self + = liftIO + (({# call webkit_dom_html_marquee_element_get_behavior #} + (toHTMLMarqueeElement self)) + >>= + readUTFString) + +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) + +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) + +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) + +getDirection :: + (MonadIO m, HTMLMarqueeElementClass self, GlibString string) => + self -> m string +getDirection self + = liftIO + (({# call webkit_dom_html_marquee_element_get_direction #} + (toHTMLMarqueeElement self)) + >>= + readUTFString) + +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) + +getHeight :: + (MonadIO m, HTMLMarqueeElementClass self, GlibString string) => + self -> m string +getHeight self + = liftIO + (({# call webkit_dom_html_marquee_element_get_height #} + (toHTMLMarqueeElement self)) + >>= + readUTFString) + +setHspace :: + (MonadIO m, HTMLMarqueeElementClass self) => self -> Word -> m () +setHspace self val + = liftIO + ({# call webkit_dom_html_marquee_element_set_hspace #} + (toHTMLMarqueeElement self) + (fromIntegral val)) + +getHspace :: + (MonadIO m, HTMLMarqueeElementClass self) => self -> m Word +getHspace self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_marquee_element_get_hspace #} + (toHTMLMarqueeElement self))) + +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_) + +getLoop :: + (MonadIO m, HTMLMarqueeElementClass self) => self -> m Int +getLoop self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_marquee_element_get_loop #} + (toHTMLMarqueeElement self))) + +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_) + +getScrollAmount :: + (MonadIO m, HTMLMarqueeElementClass self) => self -> m Int +getScrollAmount self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_marquee_element_get_scroll_amount #} + (toHTMLMarqueeElement self))) + +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_) + +getScrollDelay :: + (MonadIO m, HTMLMarqueeElementClass self) => self -> m Int +getScrollDelay self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_marquee_element_get_scroll_delay #} + (toHTMLMarqueeElement self))) + +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)) + +getTrueSpeed :: + (MonadIO m, HTMLMarqueeElementClass self) => self -> m Bool +getTrueSpeed self + = liftIO + (toBool <$> + ({# call webkit_dom_html_marquee_element_get_true_speed #} + (toHTMLMarqueeElement self))) + +setVspace :: + (MonadIO m, HTMLMarqueeElementClass self) => self -> Word -> m () +setVspace self val + = liftIO + ({# call webkit_dom_html_marquee_element_set_vspace #} + (toHTMLMarqueeElement self) + (fromIntegral val)) + +getVspace :: + (MonadIO m, HTMLMarqueeElementClass self) => self -> m Word +getVspace self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_marquee_element_get_vspace #} + (toHTMLMarqueeElement self))) + +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) + +getWidth :: + (MonadIO m, HTMLMarqueeElementClass self, GlibString string) => + self -> m string +getWidth self + = liftIO + (({# call webkit_dom_html_marquee_element_get_width #} + (toHTMLMarqueeElement self)) + >>= + readUTFString) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLMediaElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLMediaElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLMediaElement.chs @@ -0,0 +1,821 @@ +module Graphics.UI.Gtk.WebKit.DOM.HTMLMediaElement( +#if WEBKIT_CHECK_VERSION(2,2,2) +load, +#endif +#if WEBKIT_CHECK_VERSION(2,7,0) +canPlayType, +#endif +play, +pause, +#if WEBKIT_CHECK_VERSION(2,4,0) +fastSeek, +#endif +#if WEBKIT_CHECK_VERSION(99,0,0) +webkitGenerateKeyRequest, +webkitAddKey, +webkitCancelKeyRequest, +webkitSetMediaKeys, +#endif +#if WEBKIT_CHECK_VERSION(2,4,0) +addTextTrack, +#endif +#if WEBKIT_CHECK_VERSION(99,0,0) +getVideoPlaybackQuality, +#endif +#if WEBKIT_CHECK_VERSION(2,4,0) +webkitShowPlaybackTargetPicker, +#endif +pattern NETWORK_EMPTY, +pattern NETWORK_IDLE, +pattern NETWORK_LOADING, +pattern NETWORK_NO_SOURCE, +pattern HAVE_NOTHING, +pattern HAVE_METADATA, +pattern HAVE_CURRENT_DATA, +pattern HAVE_FUTURE_DATA, +pattern HAVE_ENOUGH_DATA, +getError, +setSrc, +getSrc, +getCurrentSrc, +getNetworkState, +setPreload, +getPreload, +getBuffered, +getReadyState, +getSeeking, +setCurrentTime, +getCurrentTime, +getDuration, +getPaused, +setDefaultPlaybackRate, +getDefaultPlaybackRate, +setPlaybackRate, +getPlaybackRate, +getPlayed, +getSeekable, +getEnded, +setAutoplay, +getAutoplay, +setLoop, +getLoop, +setControls, +getControls, +setVolume, +getVolume, +setMuted, +getMuted, +setDefaultMuted, +getDefaultMuted, +emptied, +loadedMetadata, +loadedData, +canPlay, +canPlayThrough, +playing, +ended, +waiting, +durationChange, +timeUpdate, +playEvent, +pauseEvent, +rateChange, +volumeChange, +setWebkitPreservesPitch, +getWebkitPreservesPitch, +getWebkitHasClosedCaptions, +setWebkitClosedCaptionsVisible, +getWebkitClosedCaptionsVisible, +getWebkitAudioDecodedByteCount, +getWebkitVideoDecodedByteCount, +webKitKeyAdded, +webKitKeyError, +webKitKeyMessage, +webKitNeedKey, +#if WEBKIT_CHECK_VERSION(99,0,0) +getWebkitKeys, +#endif +#if WEBKIT_CHECK_VERSION(2,4,0) +getAudioTracks, +getTextTracks, +getVideoTracks, +#endif +setMediaGroup, +getMediaGroup, +#if WEBKIT_CHECK_VERSION(2,4,0) +getWebkitCurrentPlaybackTargetIsWireless, +#endif +webKitCurrentPlaybackTargetIsWirelessChanged, +webKitPlaybackTargetAvailabilityChanged, +#if WEBKIT_CHECK_VERSION(99,0,0) +setSrcObject, +getSrcObject, +#endif +HTMLMediaElement, +castToHTMLMediaElement, +gTypeHTMLMediaElement, +HTMLMediaElementClass, +toHTMLMediaElement, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures +import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + + +#if WEBKIT_CHECK_VERSION(2,2,2) +load :: (MonadIO m, HTMLMediaElementClass self) => self -> m () +load self + = liftIO + ({# call webkit_dom_html_media_element_load #} + (toHTMLMediaElement self)) +#endif + +#if WEBKIT_CHECK_VERSION(2,7,0) +canPlayType :: + (MonadIO m, HTMLMediaElementClass self, GlibString string) => + self -> string -> (Maybe string) -> m string +canPlayType self type' keySystem + = liftIO + ((maybeWith withUTFString keySystem $ + \ keySystemPtr -> + withUTFString type' $ + \ typePtr -> + {# call webkit_dom_html_media_element_can_play_type #} + (toHTMLMediaElement self) + typePtr + keySystemPtr) + >>= + readUTFString) +#endif + +play :: (MonadIO m, HTMLMediaElementClass self) => self -> m () +play self + = liftIO + ({# call webkit_dom_html_media_element_play #} + (toHTMLMediaElement self)) + +pause :: (MonadIO m, HTMLMediaElementClass self) => self -> m () +pause self + = liftIO + ({# call webkit_dom_html_media_element_pause #} + (toHTMLMediaElement self)) + +#if WEBKIT_CHECK_VERSION(2,4,0) +fastSeek :: + (MonadIO m, HTMLMediaElementClass self) => self -> Double -> m () +fastSeek self time + = liftIO + ({# call webkit_dom_html_media_element_fast_seek #} + (toHTMLMediaElement self) + (realToFrac time)) +#endif + +#if WEBKIT_CHECK_VERSION(99,0,0) +webkitGenerateKeyRequest :: + (MonadIO m, HTMLMediaElementClass self, Uint8ArrayClass initData, + GlibString string) => + self -> (Maybe string) -> Maybe initData -> m () +webkitGenerateKeyRequest self keySystem initData + = liftIO + (propagateGError $ + \ errorPtr_ -> + maybeWith withUTFString keySystem $ + \ keySystemPtr -> + {# call webkit_dom_html_media_element_webkit_generate_key_request + #} + (toHTMLMediaElement self) + keySystemPtr + (maybe (Uint8Array nullForeignPtr) toUint8Array initData) + errorPtr_) + +webkitAddKey :: + (MonadIO m, HTMLMediaElementClass self, Uint8ArrayClass key, + Uint8ArrayClass initData, GlibString string) => + self -> + (Maybe string) -> Maybe key -> Maybe initData -> string -> m () +webkitAddKey self keySystem key initData sessionId + = liftIO + (propagateGError $ + \ errorPtr_ -> + withUTFString sessionId $ + \ sessionIdPtr -> + maybeWith withUTFString keySystem $ + \ keySystemPtr -> + {# call webkit_dom_html_media_element_webkit_add_key #} + (toHTMLMediaElement self) + keySystemPtr + (maybe (Uint8Array nullForeignPtr) toUint8Array key) + (maybe (Uint8Array nullForeignPtr) toUint8Array initData) + sessionIdPtr + errorPtr_) + +webkitCancelKeyRequest :: + (MonadIO m, HTMLMediaElementClass self, GlibString string) => + self -> (Maybe string) -> string -> m () +webkitCancelKeyRequest self keySystem sessionId + = liftIO + (propagateGError $ + \ errorPtr_ -> + withUTFString sessionId $ + \ sessionIdPtr -> + maybeWith withUTFString keySystem $ + \ keySystemPtr -> + {# call webkit_dom_html_media_element_webkit_cancel_key_request #} + (toHTMLMediaElement self) + keySystemPtr + sessionIdPtr + errorPtr_) + +webkitSetMediaKeys :: + (MonadIO m, HTMLMediaElementClass self, + MediaKeysClass mediaKeys) => + self -> Maybe mediaKeys -> m () +webkitSetMediaKeys self mediaKeys + = liftIO + ({# call webkit_dom_html_media_element_webkit_set_media_keys #} + (toHTMLMediaElement self) + (maybe (MediaKeys nullForeignPtr) toMediaKeys mediaKeys)) +#endif + +#if WEBKIT_CHECK_VERSION(2,4,0) +addTextTrack :: + (MonadIO m, HTMLMediaElementClass self, GlibString string) => + self -> string -> string -> string -> m (Maybe TextTrack) +addTextTrack self kind label language + = liftIO + (maybeNull (makeNewGObject mkTextTrack) + (propagateGError $ + \ errorPtr_ -> + withUTFString language $ + \ languagePtr -> + withUTFString label $ + \ labelPtr -> + withUTFString kind $ + \ kindPtr -> + {# call webkit_dom_html_media_element_add_text_track #} + (toHTMLMediaElement self) + kindPtr + labelPtr + languagePtr + errorPtr_)) +#endif + +#if WEBKIT_CHECK_VERSION(99,0,0) +getVideoPlaybackQuality :: + (MonadIO m, HTMLMediaElementClass self) => + self -> m (Maybe VideoPlaybackQuality) +getVideoPlaybackQuality self + = liftIO + (maybeNull (makeNewGObject mkVideoPlaybackQuality) + ({# call webkit_dom_html_media_element_get_video_playback_quality + #} + (toHTMLMediaElement self))) +#endif + +#if WEBKIT_CHECK_VERSION(2,4,0) +webkitShowPlaybackTargetPicker :: + (MonadIO m, HTMLMediaElementClass self) => self -> m () +webkitShowPlaybackTargetPicker self + = liftIO + ({# call + webkit_dom_html_media_element_webkit_show_playback_target_picker + #} + (toHTMLMediaElement self)) +#endif +pattern NETWORK_EMPTY = 0 +pattern NETWORK_IDLE = 1 +pattern NETWORK_LOADING = 2 +pattern NETWORK_NO_SOURCE = 3 +pattern HAVE_NOTHING = 0 +pattern HAVE_METADATA = 1 +pattern HAVE_CURRENT_DATA = 2 +pattern HAVE_FUTURE_DATA = 3 +pattern HAVE_ENOUGH_DATA = 4 + +getError :: + (MonadIO m, HTMLMediaElementClass self) => + self -> m (Maybe MediaError) +getError self + = liftIO + (maybeNull (makeNewGObject mkMediaError) + ({# call webkit_dom_html_media_element_get_error #} + (toHTMLMediaElement self))) + +setSrc :: + (MonadIO m, HTMLMediaElementClass self, GlibString string) => + self -> string -> m () +setSrc self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_media_element_set_src #} + (toHTMLMediaElement self) + valPtr) + +getSrc :: + (MonadIO m, HTMLMediaElementClass self, GlibString string) => + self -> m string +getSrc self + = liftIO + (({# call webkit_dom_html_media_element_get_src #} + (toHTMLMediaElement self)) + >>= + readUTFString) + +getCurrentSrc :: + (MonadIO m, HTMLMediaElementClass self, GlibString string) => + self -> m string +getCurrentSrc self + = liftIO + (({# call webkit_dom_html_media_element_get_current_src #} + (toHTMLMediaElement self)) + >>= + readUTFString) + +getNetworkState :: + (MonadIO m, HTMLMediaElementClass self) => self -> m Word +getNetworkState self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_media_element_get_network_state #} + (toHTMLMediaElement self))) + +setPreload :: + (MonadIO m, HTMLMediaElementClass self, GlibString string) => + self -> string -> m () +setPreload self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_media_element_set_preload #} + (toHTMLMediaElement self) + valPtr) + +getPreload :: + (MonadIO m, HTMLMediaElementClass self, GlibString string) => + self -> m string +getPreload self + = liftIO + (({# call webkit_dom_html_media_element_get_preload #} + (toHTMLMediaElement self)) + >>= + readUTFString) + +getBuffered :: + (MonadIO m, HTMLMediaElementClass self) => + self -> m (Maybe TimeRanges) +getBuffered self + = liftIO + (maybeNull (makeNewGObject mkTimeRanges) + ({# call webkit_dom_html_media_element_get_buffered #} + (toHTMLMediaElement self))) + +getReadyState :: + (MonadIO m, HTMLMediaElementClass self) => self -> m Word +getReadyState self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_media_element_get_ready_state #} + (toHTMLMediaElement self))) + +getSeeking :: + (MonadIO m, HTMLMediaElementClass self) => self -> m Bool +getSeeking self + = liftIO + (toBool <$> + ({# call webkit_dom_html_media_element_get_seeking #} + (toHTMLMediaElement self))) + +setCurrentTime :: + (MonadIO m, HTMLMediaElementClass self) => self -> Double -> m () +setCurrentTime self val + = liftIO + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_html_media_element_set_current_time #} + (toHTMLMediaElement self) + (realToFrac val) + errorPtr_) + +getCurrentTime :: + (MonadIO m, HTMLMediaElementClass self) => self -> m Double +getCurrentTime self + = liftIO + (realToFrac <$> + ({# call webkit_dom_html_media_element_get_current_time #} + (toHTMLMediaElement self))) + +getDuration :: + (MonadIO m, HTMLMediaElementClass self) => self -> m Double +getDuration self + = liftIO + (realToFrac <$> + ({# call webkit_dom_html_media_element_get_duration #} + (toHTMLMediaElement self))) + +getPaused :: + (MonadIO m, HTMLMediaElementClass self) => self -> m Bool +getPaused self + = liftIO + (toBool <$> + ({# call webkit_dom_html_media_element_get_paused #} + (toHTMLMediaElement self))) + +setDefaultPlaybackRate :: + (MonadIO m, HTMLMediaElementClass self) => self -> Double -> m () +setDefaultPlaybackRate self val + = liftIO + ({# call webkit_dom_html_media_element_set_default_playback_rate #} + (toHTMLMediaElement self) + (realToFrac val)) + +getDefaultPlaybackRate :: + (MonadIO m, HTMLMediaElementClass self) => self -> m Double +getDefaultPlaybackRate self + = liftIO + (realToFrac <$> + ({# call webkit_dom_html_media_element_get_default_playback_rate #} + (toHTMLMediaElement self))) + +setPlaybackRate :: + (MonadIO m, HTMLMediaElementClass self) => self -> Double -> m () +setPlaybackRate self val + = liftIO + ({# call webkit_dom_html_media_element_set_playback_rate #} + (toHTMLMediaElement self) + (realToFrac val)) + +getPlaybackRate :: + (MonadIO m, HTMLMediaElementClass self) => self -> m Double +getPlaybackRate self + = liftIO + (realToFrac <$> + ({# call webkit_dom_html_media_element_get_playback_rate #} + (toHTMLMediaElement self))) + +getPlayed :: + (MonadIO m, HTMLMediaElementClass self) => + self -> m (Maybe TimeRanges) +getPlayed self + = liftIO + (maybeNull (makeNewGObject mkTimeRanges) + ({# call webkit_dom_html_media_element_get_played #} + (toHTMLMediaElement self))) + +getSeekable :: + (MonadIO m, HTMLMediaElementClass self) => + self -> m (Maybe TimeRanges) +getSeekable self + = liftIO + (maybeNull (makeNewGObject mkTimeRanges) + ({# call webkit_dom_html_media_element_get_seekable #} + (toHTMLMediaElement self))) + +getEnded :: + (MonadIO m, HTMLMediaElementClass self) => self -> m Bool +getEnded self + = liftIO + (toBool <$> + ({# call webkit_dom_html_media_element_get_ended #} + (toHTMLMediaElement self))) + +setAutoplay :: + (MonadIO m, HTMLMediaElementClass self) => self -> Bool -> m () +setAutoplay self val + = liftIO + ({# call webkit_dom_html_media_element_set_autoplay #} + (toHTMLMediaElement self) + (fromBool val)) + +getAutoplay :: + (MonadIO m, HTMLMediaElementClass self) => self -> m Bool +getAutoplay self + = liftIO + (toBool <$> + ({# call webkit_dom_html_media_element_get_autoplay #} + (toHTMLMediaElement self))) + +setLoop :: + (MonadIO m, HTMLMediaElementClass self) => self -> Bool -> m () +setLoop self val + = liftIO + ({# call webkit_dom_html_media_element_set_loop #} + (toHTMLMediaElement self) + (fromBool val)) + +getLoop :: + (MonadIO m, HTMLMediaElementClass self) => self -> m Bool +getLoop self + = liftIO + (toBool <$> + ({# call webkit_dom_html_media_element_get_loop #} + (toHTMLMediaElement self))) + +setControls :: + (MonadIO m, HTMLMediaElementClass self) => self -> Bool -> m () +setControls self val + = liftIO + ({# call webkit_dom_html_media_element_set_controls #} + (toHTMLMediaElement self) + (fromBool val)) + +getControls :: + (MonadIO m, HTMLMediaElementClass self) => self -> m Bool +getControls self + = liftIO + (toBool <$> + ({# call webkit_dom_html_media_element_get_controls #} + (toHTMLMediaElement self))) + +setVolume :: + (MonadIO m, HTMLMediaElementClass self) => self -> Double -> m () +setVolume self val + = liftIO + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_html_media_element_set_volume #} + (toHTMLMediaElement self) + (realToFrac val) + errorPtr_) + +getVolume :: + (MonadIO m, HTMLMediaElementClass self) => self -> m Double +getVolume self + = liftIO + (realToFrac <$> + ({# call webkit_dom_html_media_element_get_volume #} + (toHTMLMediaElement self))) + +setMuted :: + (MonadIO m, HTMLMediaElementClass self) => self -> Bool -> m () +setMuted self val + = liftIO + ({# call webkit_dom_html_media_element_set_muted #} + (toHTMLMediaElement self) + (fromBool val)) + +getMuted :: + (MonadIO m, HTMLMediaElementClass self) => self -> m Bool +getMuted self + = liftIO + (toBool <$> + ({# call webkit_dom_html_media_element_get_muted #} + (toHTMLMediaElement self))) + +setDefaultMuted :: + (MonadIO m, HTMLMediaElementClass self) => self -> Bool -> m () +setDefaultMuted self val + = liftIO + ({# call webkit_dom_html_media_element_set_default_muted #} + (toHTMLMediaElement self) + (fromBool val)) + +getDefaultMuted :: + (MonadIO m, HTMLMediaElementClass self) => self -> m Bool +getDefaultMuted self + = liftIO + (toBool <$> + ({# call webkit_dom_html_media_element_get_default_muted #} + (toHTMLMediaElement self))) + +emptied :: (HTMLMediaElementClass self) => EventName self Event +emptied = EventName "emptied" + +loadedMetadata :: + (HTMLMediaElementClass self) => EventName self Event +loadedMetadata = EventName "loadedmetadata" + +loadedData :: (HTMLMediaElementClass self) => EventName self Event +loadedData = EventName "loadeddata" + +canPlay :: (HTMLMediaElementClass self) => EventName self Event +canPlay = EventName "canplay" + +canPlayThrough :: + (HTMLMediaElementClass self) => EventName self Event +canPlayThrough = EventName "canplaythrough" + +playing :: (HTMLMediaElementClass self) => EventName self Event +playing = EventName "playing" + +ended :: (HTMLMediaElementClass self) => EventName self Event +ended = EventName "ended" + +waiting :: (HTMLMediaElementClass self) => EventName self Event +waiting = EventName "waiting" + +durationChange :: + (HTMLMediaElementClass self) => EventName self Event +durationChange = EventName "durationchange" + +timeUpdate :: (HTMLMediaElementClass self) => EventName self Event +timeUpdate = EventName "timeupdate" + +playEvent :: (HTMLMediaElementClass self) => EventName self Event +playEvent = EventName "play" + +pauseEvent :: (HTMLMediaElementClass self) => EventName self Event +pauseEvent = EventName "pause" + +rateChange :: (HTMLMediaElementClass self) => EventName self Event +rateChange = EventName "ratechange" + +volumeChange :: + (HTMLMediaElementClass self) => EventName self Event +volumeChange = EventName "volumechange" + +setWebkitPreservesPitch :: + (MonadIO m, HTMLMediaElementClass self) => self -> Bool -> m () +setWebkitPreservesPitch self val + = liftIO + ({# call webkit_dom_html_media_element_set_webkit_preserves_pitch + #} + (toHTMLMediaElement self) + (fromBool val)) + +getWebkitPreservesPitch :: + (MonadIO m, HTMLMediaElementClass self) => self -> m Bool +getWebkitPreservesPitch self + = liftIO + (toBool <$> + ({# call webkit_dom_html_media_element_get_webkit_preserves_pitch + #} + (toHTMLMediaElement self))) + +getWebkitHasClosedCaptions :: + (MonadIO m, HTMLMediaElementClass self) => self -> m Bool +getWebkitHasClosedCaptions self + = liftIO + (toBool <$> + ({# call + webkit_dom_html_media_element_get_webkit_has_closed_captions + #} + (toHTMLMediaElement self))) + +setWebkitClosedCaptionsVisible :: + (MonadIO m, HTMLMediaElementClass self) => self -> Bool -> m () +setWebkitClosedCaptionsVisible self val + = liftIO + ({# call + webkit_dom_html_media_element_set_webkit_closed_captions_visible + #} + (toHTMLMediaElement self) + (fromBool val)) + +getWebkitClosedCaptionsVisible :: + (MonadIO m, HTMLMediaElementClass self) => self -> m Bool +getWebkitClosedCaptionsVisible self + = liftIO + (toBool <$> + ({# call + webkit_dom_html_media_element_get_webkit_closed_captions_visible + #} + (toHTMLMediaElement self))) + +getWebkitAudioDecodedByteCount :: + (MonadIO m, HTMLMediaElementClass self) => self -> m Word +getWebkitAudioDecodedByteCount self + = liftIO + (fromIntegral <$> + ({# call + webkit_dom_html_media_element_get_webkit_audio_decoded_byte_count + #} + (toHTMLMediaElement self))) + +getWebkitVideoDecodedByteCount :: + (MonadIO m, HTMLMediaElementClass self) => self -> m Word +getWebkitVideoDecodedByteCount self + = liftIO + (fromIntegral <$> + ({# call + webkit_dom_html_media_element_get_webkit_video_decoded_byte_count + #} + (toHTMLMediaElement self))) + +webKitKeyAdded :: + (HTMLMediaElementClass self) => EventName self Event +webKitKeyAdded = EventName "webkitkeyadded" + +webKitKeyError :: + (HTMLMediaElementClass self) => EventName self Event +webKitKeyError = EventName "webkitkeyerror" + +webKitKeyMessage :: + (HTMLMediaElementClass self) => EventName self Event +webKitKeyMessage = EventName "webkitkeymessage" + +webKitNeedKey :: + (HTMLMediaElementClass self) => EventName self Event +webKitNeedKey = EventName "webkitneedkey" + +#if WEBKIT_CHECK_VERSION(99,0,0) +getWebkitKeys :: + (MonadIO m, HTMLMediaElementClass self) => + self -> m (Maybe MediaKeys) +getWebkitKeys self + = liftIO + (maybeNull (makeNewGObject mkMediaKeys) + ({# call webkit_dom_html_media_element_get_webkit_keys #} + (toHTMLMediaElement self))) +#endif + +#if WEBKIT_CHECK_VERSION(2,4,0) +getAudioTracks :: + (MonadIO m, HTMLMediaElementClass self) => + self -> m (Maybe AudioTrackList) +getAudioTracks self + = liftIO + (maybeNull (makeNewGObject mkAudioTrackList) + ({# call webkit_dom_html_media_element_get_audio_tracks #} + (toHTMLMediaElement self))) + +getTextTracks :: + (MonadIO m, HTMLMediaElementClass self) => + self -> m (Maybe TextTrackList) +getTextTracks self + = liftIO + (maybeNull (makeNewGObject mkTextTrackList) + ({# call webkit_dom_html_media_element_get_text_tracks #} + (toHTMLMediaElement self))) + +getVideoTracks :: + (MonadIO m, HTMLMediaElementClass self) => + self -> m (Maybe VideoTrackList) +getVideoTracks self + = liftIO + (maybeNull (makeNewGObject mkVideoTrackList) + ({# call webkit_dom_html_media_element_get_video_tracks #} + (toHTMLMediaElement self))) +#endif + +setMediaGroup :: + (MonadIO m, HTMLMediaElementClass self, GlibString string) => + self -> (Maybe string) -> m () +setMediaGroup self val + = liftIO + (maybeWith withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_media_element_set_media_group #} + (toHTMLMediaElement self) + valPtr) + +getMediaGroup :: + (MonadIO m, HTMLMediaElementClass self, GlibString string) => + self -> m (Maybe string) +getMediaGroup self + = liftIO + (({# call webkit_dom_html_media_element_get_media_group #} + (toHTMLMediaElement self)) + >>= + maybePeek readUTFString) + +#if WEBKIT_CHECK_VERSION(2,4,0) +getWebkitCurrentPlaybackTargetIsWireless :: + (MonadIO m, HTMLMediaElementClass self) => self -> m Bool +getWebkitCurrentPlaybackTargetIsWireless self + = liftIO + (toBool <$> + ({# call + webkit_dom_html_media_element_get_webkit_current_playback_target_is_wireless + #} + (toHTMLMediaElement self))) +#endif + +webKitCurrentPlaybackTargetIsWirelessChanged :: + (HTMLMediaElementClass self) => EventName self Event +webKitCurrentPlaybackTargetIsWirelessChanged + = EventName "webkitcurrentplaybacktargetiswirelesschanged" + +webKitPlaybackTargetAvailabilityChanged :: + (HTMLMediaElementClass self) => EventName self Event +webKitPlaybackTargetAvailabilityChanged + = EventName "webkitplaybacktargetavailabilitychanged" + +#if WEBKIT_CHECK_VERSION(99,0,0) +setSrcObject :: + (MonadIO m, MediaStreamClass val, HTMLMediaElementClass self) => + self -> Maybe val -> m () +setSrcObject self val + = liftIO + ({# call webkit_dom_html_media_element_set_src_object #} + (toHTMLMediaElement self) + (maybe (MediaStream nullForeignPtr) toMediaStream val)) + +getSrcObject :: + (MonadIO m, HTMLMediaElementClass self) => + self -> m (Maybe MediaStream) +getSrcObject self + = liftIO + ({# call webkit_dom_html_media_element_get_src_object #} + (toHTMLMediaElement self)) +#endif diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLMenuElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLMenuElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLMenuElement.chs @@ -0,0 +1,39 @@ +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 + + +setCompact :: + (MonadIO m, HTMLMenuElementClass self) => self -> Bool -> m () +setCompact self val + = liftIO + ({# call webkit_dom_html_menu_element_set_compact #} + (toHTMLMenuElement self) + (fromBool val)) + +getCompact :: + (MonadIO m, HTMLMenuElementClass self) => self -> m Bool +getCompact self + = liftIO + (toBool <$> + ({# call webkit_dom_html_menu_element_get_compact #} + (toHTMLMenuElement self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLMetaElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLMetaElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLMetaElement.chs @@ -0,0 +1,113 @@ +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 + + +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) + +getContent :: + (MonadIO m, HTMLMetaElementClass self, GlibString string) => + self -> m string +getContent self + = liftIO + (({# call webkit_dom_html_meta_element_get_content #} + (toHTMLMetaElement self)) + >>= + readUTFString) + +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) + +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) + +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) + +getName :: + (MonadIO m, HTMLMetaElementClass self, GlibString string) => + self -> m string +getName self + = liftIO + (({# call webkit_dom_html_meta_element_get_name #} + (toHTMLMetaElement self)) + >>= + readUTFString) + +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) + +getScheme :: + (MonadIO m, HTMLMetaElementClass self, GlibString string) => + self -> m string +getScheme self + = liftIO + (({# call webkit_dom_html_meta_element_get_scheme #} + (toHTMLMetaElement self)) + >>= + readUTFString) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLModElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLModElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLModElement.chs @@ -0,0 +1,67 @@ +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 + + +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) + +getCite :: + (MonadIO m, HTMLModElementClass self, GlibString string) => + self -> m string +getCite self + = liftIO + (({# call webkit_dom_html_mod_element_get_cite #} + (toHTMLModElement self)) + >>= + readUTFString) + +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) + +getDateTime :: + (MonadIO m, HTMLModElementClass self, GlibString string) => + self -> m string +getDateTime self + = liftIO + (({# call webkit_dom_html_mod_element_get_date_time #} + (toHTMLModElement self)) + >>= + readUTFString) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLOListElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLOListElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLOListElement.chs @@ -0,0 +1,75 @@ +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 + + +setCompact :: + (MonadIO m, HTMLOListElementClass self) => self -> Bool -> m () +setCompact self val + = liftIO + ({# call webkit_dom_htmlo_list_element_set_compact #} + (toHTMLOListElement self) + (fromBool val)) + +getCompact :: + (MonadIO m, HTMLOListElementClass self) => self -> m Bool +getCompact self + = liftIO + (toBool <$> + ({# call webkit_dom_htmlo_list_element_get_compact #} + (toHTMLOListElement self))) + +setStart :: + (MonadIO m, HTMLOListElementClass self) => self -> Int -> m () +setStart self val + = liftIO + ({# call webkit_dom_htmlo_list_element_set_start #} + (toHTMLOListElement self) + (fromIntegral val)) + +getStart :: + (MonadIO m, HTMLOListElementClass self) => self -> m Int +getStart self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_htmlo_list_element_get_start #} + (toHTMLOListElement self))) + +setReversed :: + (MonadIO m, HTMLOListElementClass self) => self -> Bool -> m () +setReversed self val + = liftIO + ({# call webkit_dom_htmlo_list_element_set_reversed #} + (toHTMLOListElement self) + (fromBool val)) + +getReversed :: + (MonadIO m, HTMLOListElementClass self) => self -> m Bool +getReversed self + = liftIO + (toBool <$> + ({# call webkit_dom_htmlo_list_element_get_reversed #} + (toHTMLOListElement self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLObjectElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLObjectElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLObjectElement.chs @@ -0,0 +1,422 @@ +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 + + +checkValidity :: + (MonadIO m, HTMLObjectElementClass self) => self -> m Bool +checkValidity self + = liftIO + (toBool <$> + ({# call webkit_dom_html_object_element_check_validity #} + (toHTMLObjectElement self))) + +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) + +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))) + +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) + +getCode :: + (MonadIO m, HTMLObjectElementClass self, GlibString string) => + self -> m string +getCode self + = liftIO + (({# call webkit_dom_html_object_element_get_code #} + (toHTMLObjectElement self)) + >>= + readUTFString) + +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) + +getAlign :: + (MonadIO m, HTMLObjectElementClass self, GlibString string) => + self -> m string +getAlign self + = liftIO + (({# call webkit_dom_html_object_element_get_align #} + (toHTMLObjectElement self)) + >>= + readUTFString) + +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) + +getArchive :: + (MonadIO m, HTMLObjectElementClass self, GlibString string) => + self -> m string +getArchive self + = liftIO + (({# call webkit_dom_html_object_element_get_archive #} + (toHTMLObjectElement self)) + >>= + readUTFString) + +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) + +getBorder :: + (MonadIO m, HTMLObjectElementClass self, GlibString string) => + self -> m string +getBorder self + = liftIO + (({# call webkit_dom_html_object_element_get_border #} + (toHTMLObjectElement self)) + >>= + readUTFString) + +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) + +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) + +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) + +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) + +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) + +getData :: + (MonadIO m, HTMLObjectElementClass self, GlibString string) => + self -> m string +getData self + = liftIO + (({# call webkit_dom_html_object_element_get_data #} + (toHTMLObjectElement self)) + >>= + readUTFString) + +setDeclare :: + (MonadIO m, HTMLObjectElementClass self) => self -> Bool -> m () +setDeclare self val + = liftIO + ({# call webkit_dom_html_object_element_set_declare #} + (toHTMLObjectElement self) + (fromBool val)) + +getDeclare :: + (MonadIO m, HTMLObjectElementClass self) => self -> m Bool +getDeclare self + = liftIO + (toBool <$> + ({# call webkit_dom_html_object_element_get_declare #} + (toHTMLObjectElement self))) + +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) + +getHeight :: + (MonadIO m, HTMLObjectElementClass self, GlibString string) => + self -> m string +getHeight self + = liftIO + (({# call webkit_dom_html_object_element_get_height #} + (toHTMLObjectElement self)) + >>= + readUTFString) + +setHspace :: + (MonadIO m, HTMLObjectElementClass self) => self -> Int -> m () +setHspace self val + = liftIO + ({# call webkit_dom_html_object_element_set_hspace #} + (toHTMLObjectElement self) + (fromIntegral val)) + +getHspace :: + (MonadIO m, HTMLObjectElementClass self) => self -> m Int +getHspace self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_object_element_get_hspace #} + (toHTMLObjectElement self))) + +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) + +getName :: + (MonadIO m, HTMLObjectElementClass self, GlibString string) => + self -> m string +getName self + = liftIO + (({# call webkit_dom_html_object_element_get_name #} + (toHTMLObjectElement self)) + >>= + readUTFString) + +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) + +getStandby :: + (MonadIO m, HTMLObjectElementClass self, GlibString string) => + self -> m string +getStandby self + = liftIO + (({# call webkit_dom_html_object_element_get_standby #} + (toHTMLObjectElement self)) + >>= + readUTFString) + +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) + +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) + +setVspace :: + (MonadIO m, HTMLObjectElementClass self) => self -> Int -> m () +setVspace self val + = liftIO + ({# call webkit_dom_html_object_element_set_vspace #} + (toHTMLObjectElement self) + (fromIntegral val)) + +getVspace :: + (MonadIO m, HTMLObjectElementClass self) => self -> m Int +getVspace self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_object_element_get_vspace #} + (toHTMLObjectElement self))) + +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) + +getWidth :: + (MonadIO m, HTMLObjectElementClass self, GlibString string) => + self -> m string +getWidth self + = liftIO + (({# call webkit_dom_html_object_element_get_width #} + (toHTMLObjectElement self)) + >>= + readUTFString) + +getWillValidate :: + (MonadIO m, HTMLObjectElementClass self) => self -> m Bool +getWillValidate self + = liftIO + (toBool <$> + ({# call webkit_dom_html_object_element_get_will_validate #} + (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))) + +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) + +getContentDocument :: + (MonadIO m, HTMLObjectElementClass self) => + self -> m (Maybe Document) +getContentDocument self + = liftIO + (maybeNull (makeNewGObject mkDocument) + ({# call webkit_dom_html_object_element_get_content_document #} + (toHTMLObjectElement self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLOptGroupElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLOptGroupElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLOptGroupElement.chs @@ -0,0 +1,62 @@ +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 + + +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)) + +getDisabled :: + (MonadIO m, HTMLOptGroupElementClass self) => self -> m Bool +getDisabled self + = liftIO + (toBool <$> + ({# call webkit_dom_html_opt_group_element_get_disabled #} + (toHTMLOptGroupElement self))) + +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) + +getLabel :: + (MonadIO m, HTMLOptGroupElementClass self, GlibString string) => + self -> m string +getLabel self + = liftIO + (({# call webkit_dom_html_opt_group_element_get_label #} + (toHTMLOptGroupElement self)) + >>= + readUTFString) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLOptionElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLOptionElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLOptionElement.chs @@ -0,0 +1,151 @@ +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 + + +setDisabled :: + (MonadIO m, HTMLOptionElementClass self) => self -> Bool -> m () +setDisabled self val + = liftIO + ({# call webkit_dom_html_option_element_set_disabled #} + (toHTMLOptionElement self) + (fromBool val)) + +getDisabled :: + (MonadIO m, HTMLOptionElementClass self) => self -> m Bool +getDisabled self + = liftIO + (toBool <$> + ({# call webkit_dom_html_option_element_get_disabled #} + (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))) + +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) + +getLabel :: + (MonadIO m, HTMLOptionElementClass self, GlibString string) => + self -> m string +getLabel self + = liftIO + (({# call webkit_dom_html_option_element_get_label #} + (toHTMLOptionElement self)) + >>= + readUTFString) + +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)) + +getDefaultSelected :: + (MonadIO m, HTMLOptionElementClass self) => self -> m Bool +getDefaultSelected self + = liftIO + (toBool <$> + ({# call webkit_dom_html_option_element_get_default_selected #} + (toHTMLOptionElement self))) + +setSelected :: + (MonadIO m, HTMLOptionElementClass self) => self -> Bool -> m () +setSelected self val + = liftIO + ({# call webkit_dom_html_option_element_set_selected #} + (toHTMLOptionElement self) + (fromBool val)) + +getSelected :: + (MonadIO m, HTMLOptionElementClass self) => self -> m Bool +getSelected self + = liftIO + (toBool <$> + ({# call webkit_dom_html_option_element_get_selected #} + (toHTMLOptionElement self))) + +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) + +getValue :: + (MonadIO m, HTMLOptionElementClass self, GlibString string) => + self -> m string +getValue self + = liftIO + (({# call webkit_dom_html_option_element_get_value #} + (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) + +getIndex :: + (MonadIO m, HTMLOptionElementClass self) => self -> m Int +getIndex self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_option_element_get_index #} + (toHTMLOptionElement self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLOptionsCollection.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLOptionsCollection.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLOptionsCollection.chs @@ -0,0 +1,90 @@ +module Graphics.UI.Gtk.WebKit.DOM.HTMLOptionsCollection( +#if WEBKIT_CHECK_VERSION(2,2,2) +namedItem, +#endif +#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_) + +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) + (maybe (HTMLElement nullForeignPtr) toHTMLElement element) + (fromIntegral index) + errorPtr_) +#endif + +setSelectedIndex :: + (MonadIO m, HTMLOptionsCollectionClass self) => self -> Int -> m () +setSelectedIndex self val + = liftIO + ({# call webkit_dom_html_options_collection_set_selected_index #} + (toHTMLOptionsCollection self) + (fromIntegral val)) + +getSelectedIndex :: + (MonadIO m, HTMLOptionsCollectionClass self) => self -> m Int +getSelectedIndex self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_options_collection_get_selected_index #} + (toHTMLOptionsCollection self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLParagraphElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLParagraphElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLParagraphElement.chs @@ -0,0 +1,44 @@ +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 + + +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) + +getAlign :: + (MonadIO m, HTMLParagraphElementClass self, GlibString string) => + self -> m string +getAlign self + = liftIO + (({# call webkit_dom_html_paragraph_element_get_align #} + (toHTMLParagraphElement self)) + >>= + readUTFString) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLParamElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLParamElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLParamElement.chs @@ -0,0 +1,90 @@ +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 + + +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) + +getName :: + (MonadIO m, HTMLParamElementClass self, GlibString string) => + self -> m string +getName self + = liftIO + (({# call webkit_dom_html_param_element_get_name #} + (toHTMLParamElement self)) + >>= + readUTFString) + +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) + +getValue :: + (MonadIO m, HTMLParamElementClass self, GlibString string) => + self -> m string +getValue self + = liftIO + (({# call webkit_dom_html_param_element_get_value #} + (toHTMLParamElement self)) + >>= + readUTFString) + +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) + +getValueType :: + (MonadIO m, HTMLParamElementClass self, GlibString string) => + self -> m string +getValueType self + = liftIO + (({# call webkit_dom_html_param_element_get_value_type #} + (toHTMLParamElement self)) + >>= + readUTFString) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLPreElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLPreElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLPreElement.chs @@ -0,0 +1,55 @@ +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 + + +setWidth :: + (MonadIO m, HTMLPreElementClass self) => self -> Int -> m () +setWidth self val + = liftIO + ({# call webkit_dom_html_pre_element_set_width #} + (toHTMLPreElement self) + (fromIntegral val)) + +getWidth :: (MonadIO m, HTMLPreElementClass self) => self -> m Int +getWidth self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_pre_element_get_width #} + (toHTMLPreElement self))) + +setWrap :: + (MonadIO m, HTMLPreElementClass self) => self -> Bool -> m () +setWrap self val + = liftIO + ({# call webkit_dom_html_pre_element_set_wrap #} + (toHTMLPreElement self) + (fromBool val)) + +getWrap :: (MonadIO m, HTMLPreElementClass self) => self -> m Bool +getWrap self + = liftIO + (toBool <$> + ({# call webkit_dom_html_pre_element_get_wrap #} + (toHTMLPreElement self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLQuoteElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLQuoteElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLQuoteElement.chs @@ -0,0 +1,44 @@ +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 + + +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) + +getCite :: + (MonadIO m, HTMLQuoteElementClass self, GlibString string) => + self -> m string +getCite self + = liftIO + (({# call webkit_dom_html_quote_element_get_cite #} + (toHTMLQuoteElement self)) + >>= + readUTFString) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLScriptElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLScriptElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLScriptElement.chs @@ -0,0 +1,222 @@ +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, +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 +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + + +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) + +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) + +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) + +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) + +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) + +getEvent :: + (MonadIO m, HTMLScriptElementClass self, GlibString string) => + self -> m string +getEvent self + = liftIO + (({# call webkit_dom_html_script_element_get_event #} + (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) + +getCharset :: + (MonadIO m, HTMLScriptElementClass self, GlibString string) => + self -> m string +getCharset self + = liftIO + (({# call webkit_dom_html_script_element_get_charset #} + (toHTMLScriptElement self)) + >>= + readUTFString) + +setAsync :: + (MonadIO m, HTMLScriptElementClass self) => self -> Bool -> m () +setAsync self val + = liftIO + ({# call webkit_dom_html_script_element_set_async #} + (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))) + +setDefer :: + (MonadIO m, HTMLScriptElementClass self) => self -> Bool -> m () +setDefer self val + = liftIO + ({# call webkit_dom_html_script_element_set_defer #} + (toHTMLScriptElement self) + (fromBool val)) + +getDefer :: + (MonadIO m, HTMLScriptElementClass self) => self -> m Bool +getDefer self + = liftIO + (toBool <$> + ({# call webkit_dom_html_script_element_get_defer #} + (toHTMLScriptElement self))) + +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) + +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) + +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) + +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) + +getNonce :: + (MonadIO m, HTMLScriptElementClass self, GlibString string) => + self -> m string +getNonce self + = liftIO + (({# call webkit_dom_html_script_element_get_nonce #} + (toHTMLScriptElement self)) + >>= + readUTFString) +#endif diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLSelectElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLSelectElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLSelectElement.chs @@ -0,0 +1,339 @@ +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 +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 +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + + +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))) + +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)) + +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_) + +remove :: + (MonadIO m, HTMLSelectElementClass self) => self -> Int -> m () +remove self index + = liftIO + ({# call webkit_dom_html_select_element_remove #} + (toHTMLSelectElement self) + (fromIntegral index)) + +checkValidity :: + (MonadIO m, HTMLSelectElementClass self) => self -> m Bool +checkValidity self + = liftIO + (toBool <$> + ({# call webkit_dom_html_select_element_check_validity #} + (toHTMLSelectElement self))) + +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) + +setAutofocus :: + (MonadIO m, HTMLSelectElementClass self) => self -> Bool -> m () +setAutofocus self val + = liftIO + ({# call webkit_dom_html_select_element_set_autofocus #} + (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))) + +setDisabled :: + (MonadIO m, HTMLSelectElementClass self) => self -> Bool -> m () +setDisabled self val + = liftIO + ({# call webkit_dom_html_select_element_set_disabled #} + (toHTMLSelectElement self) + (fromBool val)) + +getDisabled :: + (MonadIO m, HTMLSelectElementClass self) => self -> m Bool +getDisabled self + = liftIO + (toBool <$> + ({# call webkit_dom_html_select_element_get_disabled #} + (toHTMLSelectElement self))) + +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))) + +setMultiple :: + (MonadIO m, HTMLSelectElementClass self) => self -> Bool -> m () +setMultiple self val + = liftIO + ({# call webkit_dom_html_select_element_set_multiple #} + (toHTMLSelectElement self) + (fromBool val)) + +getMultiple :: + (MonadIO m, HTMLSelectElementClass self) => self -> m Bool +getMultiple self + = liftIO + (toBool <$> + ({# call webkit_dom_html_select_element_get_multiple #} + (toHTMLSelectElement self))) + +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) + +getName :: + (MonadIO m, HTMLSelectElementClass self, GlibString string) => + self -> m string +getName self + = liftIO + (({# call webkit_dom_html_select_element_get_name #} + (toHTMLSelectElement self)) + >>= + readUTFString) + +setRequired :: + (MonadIO m, HTMLSelectElementClass self) => self -> Bool -> m () +setRequired self val + = liftIO + ({# call webkit_dom_html_select_element_set_required #} + (toHTMLSelectElement self) + (fromBool val)) + +getRequired :: + (MonadIO m, HTMLSelectElementClass self) => self -> m Bool +getRequired self + = liftIO + (toBool <$> + ({# call webkit_dom_html_select_element_get_required #} + (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)) + +getSize :: + (MonadIO m, HTMLSelectElementClass self) => self -> m Int +getSize self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_select_element_get_size #} + (toHTMLSelectElement self))) + +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))) + +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_) + +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 + +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)) + +getSelectedIndex :: + (MonadIO m, HTMLSelectElementClass self) => self -> m Int +getSelectedIndex self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_select_element_get_selected_index #} + (toHTMLSelectElement self))) + +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) + +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) + +getWillValidate :: + (MonadIO m, HTMLSelectElementClass self) => self -> m Bool +getWillValidate self + = liftIO + (toBool <$> + ({# call webkit_dom_html_select_element_get_will_validate #} + (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))) + +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) + +getLabels :: + (MonadIO m, HTMLSelectElementClass self) => + self -> m (Maybe NodeList) +getLabels self + = liftIO + (maybeNull (makeNewGObject mkNodeList) + ({# call webkit_dom_html_select_element_get_labels #} + (toHTMLSelectElement self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLStyleElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLStyleElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLStyleElement.chs @@ -0,0 +1,72 @@ +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 +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + + +setDisabled :: + (MonadIO m, HTMLStyleElementClass self) => self -> Bool -> m () +setDisabled self val + = liftIO + ({# call webkit_dom_html_style_element_set_disabled #} + (toHTMLStyleElement self) + (fromBool val)) + +getDisabled :: + (MonadIO m, HTMLStyleElementClass self) => self -> m Bool +getDisabled self + = liftIO + (toBool <$> + ({# call webkit_dom_html_style_element_get_disabled #} + (toHTMLStyleElement self))) + +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) + +getMedia :: + (MonadIO m, HTMLStyleElementClass self, GlibString string) => + self -> m string +getMedia self + = liftIO + (({# call webkit_dom_html_style_element_get_media #} + (toHTMLStyleElement self)) + >>= + readUTFString) + +getSheet :: + (MonadIO m, HTMLStyleElementClass self) => + self -> m (Maybe StyleSheet) +getSheet self + = liftIO + (maybeNull (makeNewGObject mkStyleSheet) + ({# call webkit_dom_html_style_element_get_sheet #} + (toHTMLStyleElement self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLTableCaptionElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLTableCaptionElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLTableCaptionElement.chs @@ -0,0 +1,46 @@ +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 + + +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) + +getAlign :: + (MonadIO m, HTMLTableCaptionElementClass self, + GlibString string) => + self -> m string +getAlign self + = liftIO + (({# call webkit_dom_html_table_caption_element_get_align #} + (toHTMLTableCaptionElement self)) + >>= + readUTFString) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLTableCellElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLTableCellElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLTableCellElement.chs @@ -0,0 +1,337 @@ +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 + + +getCellIndex :: + (MonadIO m, HTMLTableCellElementClass self) => self -> m Int +getCellIndex self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_table_cell_element_get_cell_index #} + (toHTMLTableCellElement self))) + +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) + +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) + +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) + +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) + +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) + +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) + +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) + +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) + +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) + +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) + +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) + +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) + +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)) + +getColSpan :: + (MonadIO m, HTMLTableCellElementClass self) => self -> m Int +getColSpan self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_table_cell_element_get_col_span #} + (toHTMLTableCellElement self))) + +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) + +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) + +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) + +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) + +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)) + +getNoWrap :: + (MonadIO m, HTMLTableCellElementClass self) => self -> m Bool +getNoWrap self + = liftIO + (toBool <$> + ({# call webkit_dom_html_table_cell_element_get_no_wrap #} + (toHTMLTableCellElement self))) + +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)) + +getRowSpan :: + (MonadIO m, HTMLTableCellElementClass self) => self -> m Int +getRowSpan self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_table_cell_element_get_row_span #} + (toHTMLTableCellElement self))) + +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) + +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) + +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) + +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) + +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) + +getWidth :: + (MonadIO m, HTMLTableCellElementClass self, GlibString string) => + self -> m string +getWidth self + = liftIO + (({# call webkit_dom_html_table_cell_element_get_width #} + (toHTMLTableCellElement self)) + >>= + readUTFString) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLTableColElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLTableColElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLTableColElement.chs @@ -0,0 +1,154 @@ +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 + + +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) + +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) + +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) + +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) + +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) + +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) + +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)) + +getSpan :: + (MonadIO m, HTMLTableColElementClass self) => self -> m Int +getSpan self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_table_col_element_get_span #} + (toHTMLTableColElement self))) + +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) + +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) + +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) + +getWidth :: + (MonadIO m, HTMLTableColElementClass self, GlibString string) => + self -> m string +getWidth self + = liftIO + (({# call webkit_dom_html_table_col_element_get_width #} + (toHTMLTableColElement self)) + >>= + readUTFString) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLTableElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLTableElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLTableElement.chs @@ -0,0 +1,420 @@ +module Graphics.UI.Gtk.WebKit.DOM.HTMLTableElement( +createTHead, +deleteTHead, +createTFoot, +deleteTFoot, +#if WEBKIT_CHECK_VERSION(2,2,2) +createTBody, +#endif +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 +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + + +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))) + +deleteTHead :: + (MonadIO m, HTMLTableElementClass self) => self -> m () +deleteTHead self + = liftIO + ({# call webkit_dom_html_table_element_delete_t_head #} + (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))) + +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 + +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)) + +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_)) + +deleteRow :: + (MonadIO m, HTMLTableElementClass self) => self -> Int -> m () +deleteRow self index + = liftIO + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_html_table_element_delete_row #} + (toHTMLTableElement self) + (fromIntegral index) + 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_) + +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))) + +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_) + +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))) + +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_) + +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))) + +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))) + +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))) + +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) + +getAlign :: + (MonadIO m, HTMLTableElementClass self, GlibString string) => + self -> m string +getAlign self + = liftIO + (({# call webkit_dom_html_table_element_get_align #} + (toHTMLTableElement self)) + >>= + readUTFString) + +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) + +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) + +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) + +getBorder :: + (MonadIO m, HTMLTableElementClass self, GlibString string) => + self -> m string +getBorder self + = liftIO + (({# call webkit_dom_html_table_element_get_border #} + (toHTMLTableElement self)) + >>= + readUTFString) + +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) + +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) + +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) + +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) + +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) + +getFrame :: + (MonadIO m, HTMLTableElementClass self, GlibString string) => + self -> m string +getFrame self + = liftIO + (({# call webkit_dom_html_table_element_get_frame #} + (toHTMLTableElement self)) + >>= + readUTFString) + +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) + +getRules :: + (MonadIO m, HTMLTableElementClass self, GlibString string) => + self -> m string +getRules self + = liftIO + (({# call webkit_dom_html_table_element_get_rules #} + (toHTMLTableElement self)) + >>= + readUTFString) + +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) + +getSummary :: + (MonadIO m, HTMLTableElementClass self, GlibString string) => + self -> m string +getSummary self + = liftIO + (({# call webkit_dom_html_table_element_get_summary #} + (toHTMLTableElement self)) + >>= + readUTFString) + +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) + +getWidth :: + (MonadIO m, HTMLTableElementClass self, GlibString string) => + self -> m string +getWidth self + = liftIO + (({# call webkit_dom_html_table_element_get_width #} + (toHTMLTableElement self)) + >>= + readUTFString) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLTableRowElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLTableRowElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLTableRowElement.chs @@ -0,0 +1,190 @@ +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 + + +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_delete_cell #} + (toHTMLTableRowElement self) + (fromIntegral index) + errorPtr_) + +getRowIndex :: + (MonadIO m, HTMLTableRowElementClass self) => self -> m Int +getRowIndex self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_table_row_element_get_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))) + +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))) + +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) + +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) + +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) + +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) + +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) + +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) + +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) + +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) + +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) + +getVAlign :: + (MonadIO m, HTMLTableRowElementClass self, GlibString string) => + self -> m string +getVAlign self + = liftIO + (({# call webkit_dom_html_table_row_element_get_v_align #} + (toHTMLTableRowElement self)) + >>= + readUTFString) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLTableSectionElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLTableSectionElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLTableSectionElement.chs @@ -0,0 +1,158 @@ +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 + + +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_delete_row #} + (toHTMLTableSectionElement self) + (fromIntegral index) + errorPtr_) + +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) + +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) + +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) + +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) + +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) + +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) + +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) + +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) + +getRows :: + (MonadIO m, HTMLTableSectionElementClass self) => + self -> m (Maybe HTMLCollection) +getRows self + = liftIO + (maybeNull (makeNewGObject mkHTMLCollection) + ({# call webkit_dom_html_table_section_element_get_rows #} + (toHTMLTableSectionElement self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLTextAreaElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLTextAreaElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLTextAreaElement.chs @@ -0,0 +1,521 @@ +module Graphics.UI.Gtk.WebKit.DOM.HTMLTextAreaElement( +checkValidity, +setCustomValidity, +select, +#if WEBKIT_CHECK_VERSION(2,2,2) +setRangeText4, +#endif +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 +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + + +checkValidity :: + (MonadIO m, HTMLTextAreaElementClass self) => self -> m Bool +checkValidity self + = liftIO + (toBool <$> + ({# call webkit_dom_html_text_area_element_check_validity #} + (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) + +select :: + (MonadIO m, HTMLTextAreaElementClass self) => self -> m () +select self + = liftIO + ({# call webkit_dom_html_text_area_element_select #} + (toHTMLTextAreaElement self)) + +#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 + +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) + +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)) + +getAutofocus :: + (MonadIO m, HTMLTextAreaElementClass self) => self -> m Bool +getAutofocus self + = liftIO + (toBool <$> + ({# call webkit_dom_html_text_area_element_get_autofocus #} + (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)) + +getCols :: + (MonadIO m, HTMLTextAreaElementClass self) => self -> m Int +getCols self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_text_area_element_get_cols #} + (toHTMLTextAreaElement self))) + +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) + +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) + +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)) + +getDisabled :: + (MonadIO m, HTMLTextAreaElementClass self) => self -> m Bool +getDisabled self + = liftIO + (toBool <$> + ({# call webkit_dom_html_text_area_element_get_disabled #} + (toHTMLTextAreaElement self))) + +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))) + +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_) + +getMaxLength :: + (MonadIO m, HTMLTextAreaElementClass self) => self -> m Int +getMaxLength self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_text_area_element_get_max_length #} + (toHTMLTextAreaElement self))) + +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) + +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) + +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) + +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) + +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)) + +getReadOnly :: + (MonadIO m, HTMLTextAreaElementClass self) => self -> m Bool +getReadOnly self + = liftIO + (toBool <$> + ({# call webkit_dom_html_text_area_element_get_read_only #} + (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)) + +getRequired :: + (MonadIO m, HTMLTextAreaElementClass self) => self -> m Bool +getRequired self + = liftIO + (toBool <$> + ({# call webkit_dom_html_text_area_element_get_required #} + (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)) + +getRows :: + (MonadIO m, HTMLTextAreaElementClass self) => self -> m Int +getRows self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_text_area_element_get_rows #} + (toHTMLTextAreaElement self))) + +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) + +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) + +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) + +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) + +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) + +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) + +getTextLength :: + (MonadIO m, HTMLTextAreaElementClass self) => self -> m Word +getTextLength self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_text_area_element_get_text_length #} + (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))) + +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))) + +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) + +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))) + +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)) + +getSelectionStart :: + (MonadIO m, HTMLTextAreaElementClass self) => self -> m Int +getSelectionStart self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_text_area_element_get_selection_start #} + (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)) + +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)) + >>= + 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)) + +getAutocorrect :: + (MonadIO m, HTMLTextAreaElementClass self) => self -> m Bool +getAutocorrect self + = liftIO + (toBool <$> + ({# call webkit_dom_html_text_area_element_get_autocorrect #} + (toHTMLTextAreaElement self))) + +setAutocapitalize :: + (MonadIO m, HTMLTextAreaElementClass self, GlibString string) => + self -> (Maybe string) -> m () +setAutocapitalize self val + = liftIO + (maybeWith withUTFString val $ + \ valPtr -> + {# call webkit_dom_html_text_area_element_set_autocapitalize #} + (toHTMLTextAreaElement self) + valPtr) + +getAutocapitalize :: + (MonadIO m, HTMLTextAreaElementClass self, GlibString string) => + self -> m (Maybe string) +getAutocapitalize self + = liftIO + (({# call webkit_dom_html_text_area_element_get_autocapitalize #} + (toHTMLTextAreaElement self)) + >>= + maybePeek readUTFString) +#endif diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLTitleElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLTitleElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLTitleElement.chs @@ -0,0 +1,44 @@ +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 + + +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) + +getText :: + (MonadIO m, HTMLTitleElementClass self, GlibString string) => + self -> m (Maybe string) +getText self + = liftIO + (({# call webkit_dom_html_title_element_get_text #} + (toHTMLTitleElement self)) + >>= + maybePeek readUTFString) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLUListElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLUListElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLUListElement.chs @@ -0,0 +1,39 @@ +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 + + +setCompact :: + (MonadIO m, HTMLUListElementClass self) => self -> Bool -> m () +setCompact self val + = liftIO + ({# call webkit_dom_htmlu_list_element_set_compact #} + (toHTMLUListElement self) + (fromBool val)) + +getCompact :: + (MonadIO m, HTMLUListElementClass self) => self -> m Bool +getCompact self + = liftIO + (toBool <$> + ({# call webkit_dom_htmlu_list_element_get_compact #} + (toHTMLUListElement self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/HTMLVideoElement.chs b/Graphics/UI/Gtk/WebKit/DOM/HTMLVideoElement.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/HTMLVideoElement.chs @@ -0,0 +1,263 @@ +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 + + +webkitEnterFullscreen :: + (MonadIO m, HTMLVideoElementClass self) => self -> m () +webkitEnterFullscreen self + = liftIO + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_html_video_element_webkit_enter_fullscreen #} + (toHTMLVideoElement self) + errorPtr_) + +webkitExitFullscreen :: + (MonadIO m, HTMLVideoElementClass self) => self -> m () +webkitExitFullscreen self + = liftIO + ({# call webkit_dom_html_video_element_webkit_exit_fullscreen #} + (toHTMLVideoElement self)) + +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_) + +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)) + +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 + +setWidth :: + (MonadIO m, HTMLVideoElementClass self) => self -> Word -> m () +setWidth self val + = liftIO + ({# call webkit_dom_html_video_element_set_width #} + (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))) + +setHeight :: + (MonadIO m, HTMLVideoElementClass self) => self -> Word -> m () +setHeight self val + = liftIO + ({# call webkit_dom_html_video_element_set_height #} + (toHTMLVideoElement self) + (fromIntegral val)) + +getHeight :: + (MonadIO m, HTMLVideoElementClass self) => self -> m Word +getHeight self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_video_element_get_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))) + +getVideoHeight :: + (MonadIO m, HTMLVideoElementClass self) => self -> m Word +getVideoHeight self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_html_video_element_get_video_height #} + (toHTMLVideoElement self))) + +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) + +getPoster :: + (MonadIO m, HTMLVideoElementClass self, GlibString string) => + self -> m string +getPoster self + = liftIO + (({# call webkit_dom_html_video_element_get_poster #} + (toHTMLVideoElement self)) + >>= + readUTFString) + +getWebkitSupportsFullscreen :: + (MonadIO m, HTMLVideoElementClass self) => self -> m Bool +getWebkitSupportsFullscreen self + = liftIO + (toBool <$> + ({# call + webkit_dom_html_video_element_get_webkit_supports_fullscreen + #} + (toHTMLVideoElement self))) + +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_set_webkit_wireless_video_playback_disabled + #} + (toHTMLVideoElement self) + (fromBool val)) + +getWebkitWirelessVideoPlaybackDisabled :: + (MonadIO m, HTMLVideoElementClass self) => self -> m Bool +getWebkitWirelessVideoPlaybackDisabled self + = liftIO + (toBool <$> + ({# call + webkit_dom_html_video_element_get_webkit_wireless_video_playback_disabled + #} + (toHTMLVideoElement self))) +#endif + +getWebkitDecodedFrameCount :: + (MonadIO m, HTMLVideoElementClass self) => self -> m Word +getWebkitDecodedFrameCount self + = liftIO + (fromIntegral <$> + ({# call + webkit_dom_html_video_element_get_webkit_decoded_frame_count + #} + (toHTMLVideoElement self))) + +getWebkitDroppedFrameCount :: + (MonadIO m, HTMLVideoElementClass self) => self -> m Word +getWebkitDroppedFrameCount self + = liftIO + (fromIntegral <$> + ({# call + webkit_dom_html_video_element_get_webkit_dropped_frame_count + #} + (toHTMLVideoElement self))) + +#if WEBKIT_CHECK_VERSION(99,0,0) +getWebkitPresentationMode :: + (MonadIO m, HTMLVideoElementClass self) => + self -> m VideoPresentationMode +getWebkitPresentationMode self + = liftIO + (stringToEnum <$> + (({# call + webkit_dom_html_video_element_get_webkit_presentation_mode + #} + (toHTMLVideoElement self)) + >>= + readUTFString)) +#endif + +webKitPresentationModeChanged :: + (HTMLVideoElementClass self) => EventName self Event +webKitPresentationModeChanged + = EventName "webkitpresentationmodechanged" diff --git a/Graphics/UI/Gtk/WebKit/DOM/History.chs b/Graphics/UI/Gtk/WebKit/DOM/History.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/History.chs @@ -0,0 +1,28 @@ +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 + + +getLength :: (MonadIO m, HistoryClass self) => self -> m Word +getLength self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_history_get_length #} (toHistory self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/KeyboardEvent.chs b/Graphics/UI/Gtk/WebKit/DOM/KeyboardEvent.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/KeyboardEvent.chs @@ -0,0 +1,162 @@ +module Graphics.UI.Gtk.WebKit.DOM.KeyboardEvent( +#if WEBKIT_CHECK_VERSION(2,2,2) +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 +KeyboardEvent, +castToKeyboardEvent, +gTypeKeyboardEvent, +KeyboardEventClass, +toKeyboardEvent, +#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 + + +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)) + +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 + = 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 + +getKeyIdentifier :: + (MonadIO m, KeyboardEventClass self, GlibString string) => + self -> m string +getKeyIdentifier self + = liftIO + (({# call webkit_dom_keyboard_event_get_key_identifier #} + (toKeyboardEvent self)) + >>= + readUTFString) + +getKeyLocation :: + (MonadIO m, KeyboardEventClass self) => self -> m Word +getKeyLocation self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_keyboard_event_get_key_location #} + (toKeyboardEvent self))) + +getCtrlKey :: + (MonadIO m, KeyboardEventClass self) => self -> m Bool +getCtrlKey self + = liftIO + (toBool <$> + ({# call webkit_dom_keyboard_event_get_ctrl_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))) + +getAltKey :: (MonadIO m, KeyboardEventClass self) => self -> m Bool +getAltKey self + = liftIO + (toBool <$> + ({# call webkit_dom_keyboard_event_get_alt_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))) + +getAltGraphKey :: + (MonadIO m, KeyboardEventClass self) => self -> m Bool +getAltGraphKey self + = liftIO + (toBool <$> + ({# call webkit_dom_keyboard_event_get_alt_graph_key #} + (toKeyboardEvent self))) + +#if WEBKIT_CHECK_VERSION(99,0,0) +getKeyCode :: (MonadIO m, KeyboardEventClass self) => self -> m Int +getKeyCode self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_keyboard_event_get_key_code #} + (toKeyboardEvent self))) + +getCharCode :: + (MonadIO m, KeyboardEventClass self) => self -> m Int +getCharCode self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_keyboard_event_get_char_code #} + (toKeyboardEvent self))) +#endif +#endif diff --git a/Graphics/UI/Gtk/WebKit/DOM/Location.chs b/Graphics/UI/Gtk/WebKit/DOM/Location.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/Location.chs @@ -0,0 +1,43 @@ +module Graphics.UI.Gtk.WebKit.DOM.Location( +getOrigin, +#if WEBKIT_CHECK_VERSION(2,2,2) +getAncestorOrigins, +#endif +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 +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + + +getOrigin :: + (MonadIO m, LocationClass self, GlibString string) => + self -> m string +getOrigin self + = liftIO + (({# call webkit_dom_location_get_origin #} (toLocation self)) >>= + readUTFString) + +#if WEBKIT_CHECK_VERSION(2,2,2) +getAncestorOrigins :: + (MonadIO m, LocationClass self) => self -> m (Maybe DOMStringList) +getAncestorOrigins self + = liftIO + (maybeNull (makeNewGObject mkDOMStringList) + ({# call webkit_dom_location_get_ancestor_origins #} + (toLocation self))) +#endif diff --git a/Graphics/UI/Gtk/WebKit/DOM/MediaError.chs b/Graphics/UI/Gtk/WebKit/DOM/MediaError.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/MediaError.chs @@ -0,0 +1,38 @@ +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 +{#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 + +getCode :: (MonadIO m, MediaErrorClass self) => self -> m Word +getCode self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_media_error_get_code #} (toMediaError self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/MediaList.chs b/Graphics/UI/Gtk/WebKit/DOM/MediaList.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/MediaList.chs @@ -0,0 +1,92 @@ +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 + + +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) + +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_) + +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_) + +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_) + +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) + +getLength :: (MonadIO m, MediaListClass self) => self -> m Word +getLength self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_media_list_get_length #} (toMediaList self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/MediaQueryList.chs b/Graphics/UI/Gtk/WebKit/DOM/MediaQueryList.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/MediaQueryList.chs @@ -0,0 +1,41 @@ +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 + + +getMedia :: + (MonadIO m, MediaQueryListClass self, GlibString string) => + self -> m string +getMedia self + = liftIO + (({# call webkit_dom_media_query_list_get_media #} + (toMediaQueryList self)) + >>= + readUTFString) + +getMatches :: + (MonadIO m, MediaQueryListClass self) => self -> m Bool +getMatches self + = liftIO + (toBool <$> + ({# call webkit_dom_media_query_list_get_matches #} + (toMediaQueryList self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/MimeType.chs b/Graphics/UI/Gtk/WebKit/DOM/MimeType.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/MimeType.chs @@ -0,0 +1,52 @@ +module Graphics.UI.Gtk.WebKit.DOM.MimeType( +getSuffixes, +getDescription, +getEnabledPlugin, +MimeType, +castToMimeType, +gTypeMimeType, +MimeTypeClass, +toMimeType, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures +import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + + +getSuffixes :: + (MonadIO m, MimeTypeClass self, GlibString string) => + self -> m string +getSuffixes self + = liftIO + (({# call webkit_dom_dom_mime_type_get_suffixes #} + (toMimeType self)) + >>= + readUTFString) + +getDescription :: + (MonadIO m, MimeTypeClass self, GlibString string) => + self -> m string +getDescription self + = liftIO + (({# call webkit_dom_dom_mime_type_get_description #} + (toMimeType self)) + >>= + readUTFString) + +getEnabledPlugin :: + (MonadIO m, MimeTypeClass self) => self -> m (Maybe Plugin) +getEnabledPlugin self + = liftIO + (maybeNull (makeNewGObject mkPlugin) + ({# call webkit_dom_dom_mime_type_get_enabled_plugin #} + (toMimeType self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/MimeTypeArray.chs b/Graphics/UI/Gtk/WebKit/DOM/MimeTypeArray.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/MimeTypeArray.chs @@ -0,0 +1,53 @@ +module Graphics.UI.Gtk.WebKit.DOM.MimeTypeArray( +item, +namedItem, +getLength, +MimeTypeArray, +castToMimeTypeArray, +gTypeMimeTypeArray, +MimeTypeArrayClass, +toMimeTypeArray, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures +import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + + +item :: + (MonadIO m, MimeTypeArrayClass self) => + self -> Word -> m (Maybe MimeType) +item self index + = liftIO + (maybeNull (makeNewGObject mkMimeType) + ({# call webkit_dom_dom_mime_type_array_item #} + (toMimeTypeArray self) + (fromIntegral index))) + +namedItem :: + (MonadIO m, MimeTypeArrayClass self, GlibString string) => + self -> string -> m (Maybe MimeType) +namedItem self name + = liftIO + (maybeNull (makeNewGObject mkMimeType) + (withUTFString name $ + \ namePtr -> + {# call webkit_dom_dom_mime_type_array_named_item #} + (toMimeTypeArray self) + namePtr)) + +getLength :: (MonadIO m, MimeTypeArrayClass self) => self -> m Word +getLength self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_dom_mime_type_array_get_length #} + (toMimeTypeArray self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/MouseEvent.chs b/Graphics/UI/Gtk/WebKit/DOM/MouseEvent.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/MouseEvent.chs @@ -0,0 +1,212 @@ +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 + + +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)) + +getScreenX :: (MonadIO m, MouseEventClass self) => self -> m Int +getScreenX self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_mouse_event_get_screen_x #} + (toMouseEvent self))) + +getScreenY :: (MonadIO m, MouseEventClass self) => self -> m Int +getScreenY self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_mouse_event_get_screen_y #} + (toMouseEvent self))) + +getClientX :: (MonadIO m, MouseEventClass self) => self -> m Int +getClientX self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_mouse_event_get_client_x #} + (toMouseEvent self))) + +getClientY :: (MonadIO m, MouseEventClass self) => self -> m Int +getClientY self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_mouse_event_get_client_y #} + (toMouseEvent self))) + +getCtrlKey :: (MonadIO m, MouseEventClass self) => self -> m Bool +getCtrlKey self + = liftIO + (toBool <$> + ({# call webkit_dom_mouse_event_get_ctrl_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))) + +getAltKey :: (MonadIO m, MouseEventClass self) => self -> m Bool +getAltKey self + = liftIO + (toBool <$> + ({# call webkit_dom_mouse_event_get_alt_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))) + +getButton :: (MonadIO m, MouseEventClass self) => self -> m Word +getButton self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_mouse_event_get_button #} (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))) + +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))) + +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))) + +getOffsetX :: (MonadIO m, MouseEventClass self) => self -> m Int +getOffsetX self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_mouse_event_get_offset_x #} + (toMouseEvent self))) + +getOffsetY :: (MonadIO m, MouseEventClass self) => self -> m Int +getOffsetY self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_mouse_event_get_offset_y #} + (toMouseEvent self))) + +getX :: (MonadIO m, MouseEventClass self) => self -> m Int +getX self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_mouse_event_get_x #} (toMouseEvent self))) + +getY :: (MonadIO m, MouseEventClass self) => self -> m Int +getY self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_mouse_event_get_y #} (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))) + +getToElement :: + (MonadIO m, MouseEventClass self) => self -> m (Maybe Node) +getToElement self + = liftIO + (maybeNull (makeNewGObject mkNode) + ({# call webkit_dom_mouse_event_get_to_element #} + (toMouseEvent self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/NamedNodeMap.chs b/Graphics/UI/Gtk/WebKit/DOM/NamedNodeMap.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/NamedNodeMap.chs @@ -0,0 +1,131 @@ +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 + + +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)) + +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_)) + +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_)) + +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))) + +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)) + +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_)) + +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_)) + +getLength :: (MonadIO m, NamedNodeMapClass self) => self -> m Word +getLength self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_named_node_map_get_length #} + (toNamedNodeMap self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/Navigator.chs b/Graphics/UI/Gtk/WebKit/DOM/Navigator.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/Navigator.chs @@ -0,0 +1,282 @@ +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_) + +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) + +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 + +javaEnabled :: (MonadIO m, NavigatorClass self) => self -> m Bool +javaEnabled self + = liftIO + (toBool <$> + ({# call webkit_dom_navigator_java_enabled #} (toNavigator self))) + +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 + +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))) + +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 + +getAppCodeName :: + (MonadIO m, NavigatorClass self, GlibString string) => + self -> m string +getAppCodeName self + = liftIO + (({# call webkit_dom_navigator_get_app_code_name #} + (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) + +getAppVersion :: + (MonadIO m, NavigatorClass self, GlibString string) => + self -> m string +getAppVersion self + = liftIO + (({# call webkit_dom_navigator_get_app_version #} + (toNavigator self)) + >>= + readUTFString) + +getLanguage :: + (MonadIO m, NavigatorClass self, GlibString string) => + self -> m string +getLanguage self + = liftIO + (({# call webkit_dom_navigator_get_language #} (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) + +getPlatform :: + (MonadIO m, NavigatorClass self, GlibString string) => + self -> m string +getPlatform self + = liftIO + (({# call webkit_dom_navigator_get_platform #} (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))) + +getMimeTypes :: + (MonadIO m, NavigatorClass self) => self -> m (Maybe MimeTypeArray) +getMimeTypes self + = liftIO + (maybeNull (makeNewGObject mkMimeTypeArray) + ({# call webkit_dom_navigator_get_mime_types #} + (toNavigator self))) + +getProduct :: + (MonadIO m, NavigatorClass self, GlibString string) => + self -> m string +getProduct self + = liftIO + (({# call webkit_dom_navigator_get_product #} (toNavigator self)) + >>= + readUTFString) + +getProductSub :: + (MonadIO m, NavigatorClass self, GlibString string) => + self -> m string +getProductSub self + = liftIO + (({# call webkit_dom_navigator_get_product_sub #} + (toNavigator self)) + >>= + readUTFString) + +getVendor :: + (MonadIO m, NavigatorClass self, GlibString string) => + self -> m string +getVendor self + = liftIO + (({# call webkit_dom_navigator_get_vendor #} (toNavigator self)) + >>= + readUTFString) + +getVendorSub :: + (MonadIO m, NavigatorClass self, GlibString string) => + self -> m string +getVendorSub self + = liftIO + (({# call webkit_dom_navigator_get_vendor_sub #} + (toNavigator self)) + >>= + readUTFString) + +getCookieEnabled :: + (MonadIO m, NavigatorClass self) => self -> m Bool +getCookieEnabled self + = liftIO + (toBool <$> + ({# call webkit_dom_navigator_get_cookie_enabled #} + (toNavigator self))) + +getOnLine :: (MonadIO m, NavigatorClass self) => self -> m Bool +getOnLine self + = liftIO + (toBool <$> + ({# call webkit_dom_navigator_get_on_line #} (toNavigator self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/Node.chs b/Graphics/UI/Gtk/WebKit/DOM/Node.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/Node.chs @@ -0,0 +1,399 @@ +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 + + +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_)) + +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_)) + +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_)) + +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_)) + +hasChildNodes :: (MonadIO m, NodeClass self) => self -> m Bool +hasChildNodes self + = liftIO + (toBool <$> + ({# call webkit_dom_node_has_child_nodes #} (toNode self))) + +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))) + +normalize :: (MonadIO m, NodeClass self) => self -> m () +normalize self + = liftIO ({# call webkit_dom_node_normalize #} (toNode self)) + +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)) + +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))) + +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))) + +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) + +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)) + +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) + +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))) + +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 + +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_ -> + maybeWith withUTFString val $ + \ valPtr -> + {# call webkit_dom_node_set_node_value #} (toNode self) valPtr + errorPtr_) + +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) + +getNodeType :: (MonadIO m, NodeClass self) => self -> m Word +getNodeType self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_node_get_node_type #} (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))) + +getChildNodes :: + (MonadIO m, NodeClass self) => self -> m (Maybe NodeList) +getChildNodes self + = liftIO + (maybeNull (makeNewGObject mkNodeList) + ({# call webkit_dom_node_get_child_nodes #} (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))) + +getLastChild :: + (MonadIO m, NodeClass self) => self -> m (Maybe Node) +getLastChild self + = liftIO + (maybeNull (makeNewGObject mkNode) + ({# call webkit_dom_node_get_last_child #} (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))) + +getNextSibling :: + (MonadIO m, NodeClass self) => self -> m (Maybe Node) +getNextSibling self + = liftIO + (maybeNull (makeNewGObject mkNode) + ({# call webkit_dom_node_get_next_sibling #} (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))) + +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) + +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_) + +getPrefix :: + (MonadIO m, NodeClass self, GlibString string) => + self -> m (Maybe string) +getPrefix self + = liftIO + (({# call webkit_dom_node_get_prefix #} (toNode self)) >>= + maybePeek 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) + +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) + +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_) + +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) + +getParentElement :: + (MonadIO m, NodeClass self) => self -> m (Maybe Element) +getParentElement self + = liftIO + (maybeNull (makeNewGObject mkElement) + ({# call webkit_dom_node_get_parent_element #} (toNode self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/NodeFilter.chs b/Graphics/UI/Gtk/WebKit/DOM/NodeFilter.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/NodeFilter.chs @@ -0,0 +1,53 @@ +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 +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + +pattern FILTER_ACCEPT = 1 +pattern FILTER_REJECT = 2 +pattern FILTER_SKIP = 3 +pattern SHOW_ALL = 4294967295 +pattern SHOW_ELEMENT = 1 +pattern SHOW_ATTRIBUTE = 2 +pattern SHOW_TEXT = 4 +pattern SHOW_CDATA_SECTION = 8 +pattern SHOW_ENTITY_REFERENCE = 16 +pattern SHOW_ENTITY = 32 +pattern SHOW_PROCESSING_INSTRUCTION = 64 +pattern SHOW_COMMENT = 128 +pattern SHOW_DOCUMENT = 256 +pattern SHOW_DOCUMENT_TYPE = 512 +pattern SHOW_DOCUMENT_FRAGMENT = 1024 +pattern SHOW_NOTATION = 2048 diff --git a/Graphics/UI/Gtk/WebKit/DOM/NodeIterator.chs b/Graphics/UI/Gtk/WebKit/DOM/NodeIterator.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/NodeIterator.chs @@ -0,0 +1,82 @@ +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 + + +detach :: (MonadIO m, NodeIteratorClass self) => self -> m () +detach self + = liftIO + ({# call webkit_dom_node_iterator_detach #} (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))) + +getWhatToShow :: + (MonadIO m, NodeIteratorClass self) => self -> m Word +getWhatToShow self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_node_iterator_get_what_to_show #} + (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))) + +getExpandEntityReferences :: + (MonadIO m, NodeIteratorClass self) => self -> m Bool +getExpandEntityReferences self + = liftIO + (toBool <$> + ({# call webkit_dom_node_iterator_get_expand_entity_references #} + (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))) + +getPointerBeforeReferenceNode :: + (MonadIO m, NodeIteratorClass self) => self -> m Bool +getPointerBeforeReferenceNode self + = liftIO + (toBool <$> + ({# call webkit_dom_node_iterator_get_pointer_before_reference_node + #} + (toNodeIterator self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/NodeList.chs b/Graphics/UI/Gtk/WebKit/DOM/NodeList.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/NodeList.chs @@ -0,0 +1,37 @@ +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 + + +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))) + +getLength :: (MonadIO m, NodeListClass self) => self -> m Word +getLength self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_node_list_get_length #} (toNodeList self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/Performance.chs b/Graphics/UI/Gtk/WebKit/DOM/Performance.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/Performance.chs @@ -0,0 +1,52 @@ +module Graphics.UI.Gtk.WebKit.DOM.Performance( +#if WEBKIT_CHECK_VERSION(2,2,2) +now, +getNavigation, +getTiming, +Performance, +castToPerformance, +gTypePerformance, +PerformanceClass, +toPerformance, +#endif +) where +#if WEBKIT_CHECK_VERSION(2,2,2) +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures +import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + + +now :: (MonadIO m, PerformanceClass self) => self -> m Double +now self + = liftIO + (realToFrac <$> + ({# call webkit_dom_performance_now #} (toPerformance self))) + +getNavigation :: + (MonadIO m, PerformanceClass self) => + self -> m (Maybe PerformanceNavigation) +getNavigation self + = liftIO + (maybeNull (makeNewGObject mkPerformanceNavigation) + ({# call webkit_dom_performance_get_navigation #} + (toPerformance self))) + +getTiming :: + (MonadIO m, PerformanceClass self) => + self -> m (Maybe PerformanceTiming) +getTiming self + = liftIO + (maybeNull (makeNewGObject mkPerformanceTiming) + ({# call webkit_dom_performance_get_timing #} + (toPerformance self))) +#endif diff --git a/Graphics/UI/Gtk/WebKit/DOM/PerformanceNavigation.chs b/Graphics/UI/Gtk/WebKit/DOM/PerformanceNavigation.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/PerformanceNavigation.chs @@ -0,0 +1,42 @@ +module Graphics.UI.Gtk.WebKit.DOM.PerformanceNavigation( +#if WEBKIT_CHECK_VERSION(2,2,2) +pattern TYPE_NAVIGATE, +pattern TYPE_RELOAD, +pattern TYPE_BACK_FORWARD, +pattern TYPE_RESERVED, +getRedirectCount, +PerformanceNavigation, +castToPerformanceNavigation, +gTypePerformanceNavigation, +PerformanceNavigationClass, +toPerformanceNavigation, +#endif +) where +#if WEBKIT_CHECK_VERSION(2,2,2) +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures +import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + +pattern TYPE_NAVIGATE = 0 +pattern TYPE_RELOAD = 1 +pattern TYPE_BACK_FORWARD = 2 +pattern TYPE_RESERVED = 255 + +getRedirectCount :: + (MonadIO m, PerformanceNavigationClass self) => self -> m Word +getRedirectCount self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_performance_navigation_get_redirect_count #} + (toPerformanceNavigation self))) +#endif diff --git a/Graphics/UI/Gtk/WebKit/DOM/PerformanceTiming.chs b/Graphics/UI/Gtk/WebKit/DOM/PerformanceTiming.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/PerformanceTiming.chs @@ -0,0 +1,219 @@ +module Graphics.UI.Gtk.WebKit.DOM.PerformanceTiming( +#if WEBKIT_CHECK_VERSION(2,2,2) +getNavigationStart, +getUnloadEventStart, +getUnloadEventEnd, +getRedirectStart, +getRedirectEnd, +getFetchStart, +getDomainLookupStart, +getDomainLookupEnd, +getConnectStart, +getConnectEnd, +getSecureConnectionStart, +getRequestStart, +getResponseStart, +getResponseEnd, +getDomLoading, +getDomInteractive, +getDomContentLoadedEventStart, +getDomContentLoadedEventEnd, +getDomComplete, +getLoadEventStart, +getLoadEventEnd, +PerformanceTiming, +castToPerformanceTiming, +gTypePerformanceTiming, +PerformanceTimingClass, +toPerformanceTiming, +#endif +) where +#if WEBKIT_CHECK_VERSION(2,2,2) +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures +import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + + +getNavigationStart :: + (MonadIO m, PerformanceTimingClass self) => self -> m Word64 +getNavigationStart self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_performance_timing_get_navigation_start #} + (toPerformanceTiming self))) + +getUnloadEventStart :: + (MonadIO m, PerformanceTimingClass self) => self -> m Word64 +getUnloadEventStart self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_performance_timing_get_unload_event_start #} + (toPerformanceTiming self))) + +getUnloadEventEnd :: + (MonadIO m, PerformanceTimingClass self) => self -> m Word64 +getUnloadEventEnd self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_performance_timing_get_unload_event_end #} + (toPerformanceTiming self))) + +getRedirectStart :: + (MonadIO m, PerformanceTimingClass self) => self -> m Word64 +getRedirectStart self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_performance_timing_get_redirect_start #} + (toPerformanceTiming self))) + +getRedirectEnd :: + (MonadIO m, PerformanceTimingClass self) => self -> m Word64 +getRedirectEnd self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_performance_timing_get_redirect_end #} + (toPerformanceTiming self))) + +getFetchStart :: + (MonadIO m, PerformanceTimingClass self) => self -> m Word64 +getFetchStart self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_performance_timing_get_fetch_start #} + (toPerformanceTiming self))) + +getDomainLookupStart :: + (MonadIO m, PerformanceTimingClass self) => self -> m Word64 +getDomainLookupStart self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_performance_timing_get_domain_lookup_start #} + (toPerformanceTiming self))) + +getDomainLookupEnd :: + (MonadIO m, PerformanceTimingClass self) => self -> m Word64 +getDomainLookupEnd self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_performance_timing_get_domain_lookup_end #} + (toPerformanceTiming self))) + +getConnectStart :: + (MonadIO m, PerformanceTimingClass self) => self -> m Word64 +getConnectStart self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_performance_timing_get_connect_start #} + (toPerformanceTiming self))) + +getConnectEnd :: + (MonadIO m, PerformanceTimingClass self) => self -> m Word64 +getConnectEnd self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_performance_timing_get_connect_end #} + (toPerformanceTiming self))) + +getSecureConnectionStart :: + (MonadIO m, PerformanceTimingClass self) => self -> m Word64 +getSecureConnectionStart self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_performance_timing_get_secure_connection_start + #} + (toPerformanceTiming self))) + +getRequestStart :: + (MonadIO m, PerformanceTimingClass self) => self -> m Word64 +getRequestStart self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_performance_timing_get_request_start #} + (toPerformanceTiming self))) + +getResponseStart :: + (MonadIO m, PerformanceTimingClass self) => self -> m Word64 +getResponseStart self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_performance_timing_get_response_start #} + (toPerformanceTiming self))) + +getResponseEnd :: + (MonadIO m, PerformanceTimingClass self) => self -> m Word64 +getResponseEnd self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_performance_timing_get_response_end #} + (toPerformanceTiming self))) + +getDomLoading :: + (MonadIO m, PerformanceTimingClass self) => self -> m Word64 +getDomLoading self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_performance_timing_get_dom_loading #} + (toPerformanceTiming self))) + +getDomInteractive :: + (MonadIO m, PerformanceTimingClass self) => self -> m Word64 +getDomInteractive self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_performance_timing_get_dom_interactive #} + (toPerformanceTiming self))) + +getDomContentLoadedEventStart :: + (MonadIO m, PerformanceTimingClass self) => self -> m Word64 +getDomContentLoadedEventStart self + = liftIO + (fromIntegral <$> + ({# call + webkit_dom_performance_timing_get_dom_content_loaded_event_start + #} + (toPerformanceTiming self))) + +getDomContentLoadedEventEnd :: + (MonadIO m, PerformanceTimingClass self) => self -> m Word64 +getDomContentLoadedEventEnd self + = liftIO + (fromIntegral <$> + ({# call + webkit_dom_performance_timing_get_dom_content_loaded_event_end + #} + (toPerformanceTiming self))) + +getDomComplete :: + (MonadIO m, PerformanceTimingClass self) => self -> m Word64 +getDomComplete self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_performance_timing_get_dom_complete #} + (toPerformanceTiming self))) + +getLoadEventStart :: + (MonadIO m, PerformanceTimingClass self) => self -> m Word64 +getLoadEventStart self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_performance_timing_get_load_event_start #} + (toPerformanceTiming self))) + +getLoadEventEnd :: + (MonadIO m, PerformanceTimingClass self) => self -> m Word64 +getLoadEventEnd self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_performance_timing_get_load_event_end #} + (toPerformanceTiming self))) +#endif diff --git a/Graphics/UI/Gtk/WebKit/DOM/Plugin.chs b/Graphics/UI/Gtk/WebKit/DOM/Plugin.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/Plugin.chs @@ -0,0 +1,78 @@ +module Graphics.UI.Gtk.WebKit.DOM.Plugin( +item, +namedItem, +getName, +getFilename, +getDescription, +getLength, +Plugin, +castToPlugin, +gTypePlugin, +PluginClass, +toPlugin, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures +import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + + +item :: + (MonadIO m, PluginClass self) => self -> Word -> m (Maybe MimeType) +item self index + = liftIO + (maybeNull (makeNewGObject mkMimeType) + ({# call webkit_dom_dom_plugin_item #} (toPlugin self) + (fromIntegral index))) + +namedItem :: + (MonadIO m, PluginClass self, GlibString string) => + self -> string -> m (Maybe MimeType) +namedItem self name + = liftIO + (maybeNull (makeNewGObject mkMimeType) + (withUTFString name $ + \ namePtr -> + {# call webkit_dom_dom_plugin_named_item #} (toPlugin self) + namePtr)) + +getName :: + (MonadIO m, PluginClass self, GlibString string) => + self -> m string +getName self + = liftIO + (({# call webkit_dom_dom_plugin_get_name #} (toPlugin self)) >>= + readUTFString) + +getFilename :: + (MonadIO m, PluginClass self, GlibString string) => + self -> m string +getFilename self + = liftIO + (({# call webkit_dom_dom_plugin_get_filename #} (toPlugin self)) + >>= + readUTFString) + +getDescription :: + (MonadIO m, PluginClass self, GlibString string) => + self -> m string +getDescription self + = liftIO + (({# call webkit_dom_dom_plugin_get_description #} (toPlugin self)) + >>= + readUTFString) + +getLength :: (MonadIO m, PluginClass self) => self -> m Word +getLength self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_dom_plugin_get_length #} (toPlugin self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/PluginArray.chs b/Graphics/UI/Gtk/WebKit/DOM/PluginArray.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/PluginArray.chs @@ -0,0 +1,61 @@ +module Graphics.UI.Gtk.WebKit.DOM.PluginArray( +item, +namedItem, +refresh, +getLength, +PluginArray, +castToPluginArray, +gTypePluginArray, +PluginArrayClass, +toPluginArray, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures +import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + + +item :: + (MonadIO m, PluginArrayClass self) => + self -> Word -> m (Maybe Plugin) +item self index + = liftIO + (maybeNull (makeNewGObject mkPlugin) + ({# call webkit_dom_dom_plugin_array_item #} (toPluginArray self) + (fromIntegral index))) + +namedItem :: + (MonadIO m, PluginArrayClass self, GlibString string) => + self -> string -> m (Maybe Plugin) +namedItem self name + = liftIO + (maybeNull (makeNewGObject mkPlugin) + (withUTFString name $ + \ namePtr -> + {# call webkit_dom_dom_plugin_array_named_item #} + (toPluginArray self) + namePtr)) + +refresh :: + (MonadIO m, PluginArrayClass self) => self -> Bool -> m () +refresh self reload + = liftIO + ({# call webkit_dom_dom_plugin_array_refresh #} + (toPluginArray self) + (fromBool reload)) + +getLength :: (MonadIO m, PluginArrayClass self) => self -> m Word +getLength self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_dom_plugin_array_get_length #} + (toPluginArray self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/ProcessingInstruction.chs b/Graphics/UI/Gtk/WebKit/DOM/ProcessingInstruction.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/ProcessingInstruction.chs @@ -0,0 +1,42 @@ +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 +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + + +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) + +getSheet :: + (MonadIO m, ProcessingInstructionClass self) => + self -> m (Maybe StyleSheet) +getSheet self + = liftIO + (maybeNull (makeNewGObject mkStyleSheet) + ({# call webkit_dom_processing_instruction_get_sheet #} + (toProcessingInstruction self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/Range.chs b/Graphics/UI/Gtk/WebKit/DOM/Range.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/Range.chs @@ -0,0 +1,398 @@ +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 +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + + +setStart :: + (MonadIO m, RangeClass self, NodeClass refNode) => + self -> Maybe refNode -> Int -> m () +setStart self refNode offset + = liftIO + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_range_set_start #} (toRange self) + (maybe (Node nullForeignPtr) toNode refNode) + (fromIntegral offset) + errorPtr_) + +setEnd :: + (MonadIO m, RangeClass self, NodeClass refNode) => + self -> Maybe refNode -> Int -> m () +setEnd self refNode offset + = liftIO + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_range_set_end #} (toRange self) + (maybe (Node nullForeignPtr) toNode refNode) + (fromIntegral offset) + errorPtr_) + +setStartBefore :: + (MonadIO m, RangeClass self, NodeClass refNode) => + self -> Maybe refNode -> m () +setStartBefore self refNode + = liftIO + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_range_set_start_before #} (toRange self) + (maybe (Node nullForeignPtr) toNode refNode) + errorPtr_) + +setStartAfter :: + (MonadIO m, RangeClass self, NodeClass refNode) => + self -> Maybe refNode -> m () +setStartAfter self refNode + = liftIO + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_range_set_start_after #} (toRange self) + (maybe (Node nullForeignPtr) toNode refNode) + errorPtr_) + +setEndBefore :: + (MonadIO m, RangeClass self, NodeClass refNode) => + self -> Maybe refNode -> m () +setEndBefore self refNode + = liftIO + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_range_set_end_before #} (toRange self) + (maybe (Node nullForeignPtr) toNode refNode) + errorPtr_) + +setEndAfter :: + (MonadIO m, RangeClass self, NodeClass refNode) => + self -> Maybe refNode -> m () +setEndAfter self refNode + = liftIO + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_range_set_end_after #} (toRange self) + (maybe (Node nullForeignPtr) toNode refNode) + errorPtr_) + +collapse :: (MonadIO m, RangeClass self) => self -> Bool -> m () +collapse self toStart + = liftIO + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_range_collapse #} (toRange self) + (fromBool toStart) + errorPtr_) + +selectNode :: + (MonadIO m, RangeClass self, NodeClass refNode) => + self -> Maybe refNode -> m () +selectNode self refNode + = liftIO + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_range_select_node #} (toRange self) + (maybe (Node nullForeignPtr) toNode refNode) + errorPtr_) + +selectNodeContents :: + (MonadIO m, RangeClass self, NodeClass refNode) => + self -> Maybe refNode -> m () +selectNodeContents self refNode + = liftIO + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_range_select_node_contents #} (toRange self) + (maybe (Node nullForeignPtr) toNode refNode) + errorPtr_) + +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_)) + +deleteContents :: (MonadIO m, RangeClass self) => self -> m () +deleteContents self + = liftIO + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_range_delete_contents #} (toRange 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_)) + +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_insert_node #} (toRange self) + (maybe (Node nullForeignPtr) toNode newNode) + errorPtr_) + +surroundContents :: + (MonadIO m, RangeClass self, NodeClass newParent) => + self -> Maybe newParent -> m () +surroundContents self newParent + = liftIO + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_range_surround_contents #} (toRange self) + (maybe (Node nullForeignPtr) toNode newParent) + errorPtr_) + +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_detach #} (toRange self) errorPtr_) + +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_ -> + 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 + +getStartContainer :: + (MonadIO m, RangeClass self) => self -> m (Maybe Node) +getStartContainer self + = liftIO + (maybeNull (makeNewGObject mkNode) + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_range_get_start_container #} (toRange self) + errorPtr_)) + +getStartOffset :: (MonadIO m, RangeClass self) => self -> m Int +getStartOffset self + = liftIO + (fromIntegral <$> + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_range_get_start_offset #} (toRange self) + errorPtr_)) + +getEndContainer :: + (MonadIO m, RangeClass self) => self -> m (Maybe Node) +getEndContainer self + = liftIO + (maybeNull (makeNewGObject mkNode) + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_range_get_end_container #} (toRange self) + errorPtr_)) + +getEndOffset :: (MonadIO m, RangeClass self) => self -> m Int +getEndOffset self + = liftIO + (fromIntegral <$> + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_range_get_end_offset #} (toRange self) + errorPtr_)) + +getCollapsed :: (MonadIO m, RangeClass self) => self -> m Bool +getCollapsed self + = liftIO + (toBool <$> + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_range_get_collapsed #} (toRange self) + errorPtr_)) + +getCommonAncestorContainer :: + (MonadIO m, RangeClass self) => self -> m (Maybe Node) +getCommonAncestorContainer self + = liftIO + (maybeNull (makeNewGObject mkNode) + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_range_get_common_ancestor_container #} + (toRange self) + errorPtr_)) + +getText :: + (MonadIO m, RangeClass self, GlibString string) => self -> m string +getText self + = liftIO + (({# call webkit_dom_range_get_text #} (toRange self)) >>= + readUTFString) diff --git a/Graphics/UI/Gtk/WebKit/DOM/Screen.chs b/Graphics/UI/Gtk/WebKit/DOM/Screen.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/Screen.chs @@ -0,0 +1,77 @@ +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 + + +getHeight :: (MonadIO m, ScreenClass self) => self -> m Word +getHeight self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_screen_get_height #} (toScreen self))) + +getWidth :: (MonadIO m, ScreenClass self) => self -> m Word +getWidth self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_screen_get_width #} (toScreen self))) + +getColorDepth :: (MonadIO m, ScreenClass self) => self -> m Word +getColorDepth self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_screen_get_color_depth #} (toScreen self))) + +getPixelDepth :: (MonadIO m, ScreenClass self) => self -> m Word +getPixelDepth self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_screen_get_pixel_depth #} (toScreen self))) + +getAvailLeft :: (MonadIO m, ScreenClass self) => self -> m Int +getAvailLeft self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_screen_get_avail_left #} (toScreen self))) + +getAvailTop :: (MonadIO m, ScreenClass self) => self -> m Int +getAvailTop self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_screen_get_avail_top #} (toScreen self))) + +getAvailHeight :: (MonadIO m, ScreenClass self) => self -> m Word +getAvailHeight self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_screen_get_avail_height #} (toScreen self))) + +getAvailWidth :: (MonadIO m, ScreenClass self) => self -> m Word +getAvailWidth self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_screen_get_avail_width #} (toScreen self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/SecurityPolicy.chs b/Graphics/UI/Gtk/WebKit/DOM/SecurityPolicy.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/SecurityPolicy.chs @@ -0,0 +1,201 @@ +module Graphics.UI.Gtk.WebKit.DOM.SecurityPolicy( +#if WEBKIT_CHECK_VERSION(2,2,2) +allowsConnectionTo, +allowsFontFrom, +allowsFormAction, +allowsFrameFrom, +allowsImageFrom, +allowsMediaFrom, +allowsObjectFrom, +allowsPluginType, +allowsScriptFrom, +allowsStyleFrom, +getAllowsEval, +getAllowsInlineScript, +getAllowsInlineStyle, +getIsActive, +getReportURIs, +SecurityPolicy, +castToSecurityPolicy, +gTypeSecurityPolicy, +SecurityPolicyClass, +toSecurityPolicy, +#endif +) where +#if WEBKIT_CHECK_VERSION(2,2,2) +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures +import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + + +allowsConnectionTo :: + (MonadIO m, SecurityPolicyClass self, GlibString string) => + self -> string -> m Bool +allowsConnectionTo self url + = liftIO + (toBool <$> + (withUTFString url $ + \ urlPtr -> + {# call webkit_dom_dom_security_policy_allows_connection_to #} + (toSecurityPolicy self) + urlPtr)) + +allowsFontFrom :: + (MonadIO m, SecurityPolicyClass self, GlibString string) => + self -> string -> m Bool +allowsFontFrom self url + = liftIO + (toBool <$> + (withUTFString url $ + \ urlPtr -> + {# call webkit_dom_dom_security_policy_allows_font_from #} + (toSecurityPolicy self) + urlPtr)) + +allowsFormAction :: + (MonadIO m, SecurityPolicyClass self, GlibString string) => + self -> string -> m Bool +allowsFormAction self url + = liftIO + (toBool <$> + (withUTFString url $ + \ urlPtr -> + {# call webkit_dom_dom_security_policy_allows_form_action #} + (toSecurityPolicy self) + urlPtr)) + +allowsFrameFrom :: + (MonadIO m, SecurityPolicyClass self, GlibString string) => + self -> string -> m Bool +allowsFrameFrom self url + = liftIO + (toBool <$> + (withUTFString url $ + \ urlPtr -> + {# call webkit_dom_dom_security_policy_allows_frame_from #} + (toSecurityPolicy self) + urlPtr)) + +allowsImageFrom :: + (MonadIO m, SecurityPolicyClass self, GlibString string) => + self -> string -> m Bool +allowsImageFrom self url + = liftIO + (toBool <$> + (withUTFString url $ + \ urlPtr -> + {# call webkit_dom_dom_security_policy_allows_image_from #} + (toSecurityPolicy self) + urlPtr)) + +allowsMediaFrom :: + (MonadIO m, SecurityPolicyClass self, GlibString string) => + self -> string -> m Bool +allowsMediaFrom self url + = liftIO + (toBool <$> + (withUTFString url $ + \ urlPtr -> + {# call webkit_dom_dom_security_policy_allows_media_from #} + (toSecurityPolicy self) + urlPtr)) + +allowsObjectFrom :: + (MonadIO m, SecurityPolicyClass self, GlibString string) => + self -> string -> m Bool +allowsObjectFrom self url + = liftIO + (toBool <$> + (withUTFString url $ + \ urlPtr -> + {# call webkit_dom_dom_security_policy_allows_object_from #} + (toSecurityPolicy self) + urlPtr)) + +allowsPluginType :: + (MonadIO m, SecurityPolicyClass self, GlibString string) => + self -> string -> m Bool +allowsPluginType self type' + = liftIO + (toBool <$> + (withUTFString type' $ + \ typePtr -> + {# call webkit_dom_dom_security_policy_allows_plugin_type #} + (toSecurityPolicy self) + typePtr)) + +allowsScriptFrom :: + (MonadIO m, SecurityPolicyClass self, GlibString string) => + self -> string -> m Bool +allowsScriptFrom self url + = liftIO + (toBool <$> + (withUTFString url $ + \ urlPtr -> + {# call webkit_dom_dom_security_policy_allows_script_from #} + (toSecurityPolicy self) + urlPtr)) + +allowsStyleFrom :: + (MonadIO m, SecurityPolicyClass self, GlibString string) => + self -> string -> m Bool +allowsStyleFrom self url + = liftIO + (toBool <$> + (withUTFString url $ + \ urlPtr -> + {# call webkit_dom_dom_security_policy_allows_style_from #} + (toSecurityPolicy self) + urlPtr)) + +getAllowsEval :: + (MonadIO m, SecurityPolicyClass self) => self -> m Bool +getAllowsEval self + = liftIO + (toBool <$> + ({# call webkit_dom_dom_security_policy_get_allows_eval #} + (toSecurityPolicy self))) + +getAllowsInlineScript :: + (MonadIO m, SecurityPolicyClass self) => self -> m Bool +getAllowsInlineScript self + = liftIO + (toBool <$> + ({# call webkit_dom_dom_security_policy_get_allows_inline_script #} + (toSecurityPolicy self))) + +getAllowsInlineStyle :: + (MonadIO m, SecurityPolicyClass self) => self -> m Bool +getAllowsInlineStyle self + = liftIO + (toBool <$> + ({# call webkit_dom_dom_security_policy_get_allows_inline_style #} + (toSecurityPolicy self))) + +getIsActive :: + (MonadIO m, SecurityPolicyClass self) => self -> m Bool +getIsActive self + = liftIO + (toBool <$> + ({# call webkit_dom_dom_security_policy_get_is_active #} + (toSecurityPolicy self))) + +getReportURIs :: + (MonadIO m, SecurityPolicyClass self) => + self -> m (Maybe DOMStringList) +getReportURIs self + = liftIO + (maybeNull (makeNewGObject mkDOMStringList) + ({# call webkit_dom_dom_security_policy_get_report_ur_is #} + (toSecurityPolicy self))) +#endif diff --git a/Graphics/UI/Gtk/WebKit/DOM/Selection.chs b/Graphics/UI/Gtk/WebKit/DOM/Selection.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/Selection.chs @@ -0,0 +1,268 @@ +module Graphics.UI.Gtk.WebKit.DOM.Selection( +collapse, +collapseToEnd, +collapseToStart, +deleteFromDocument, +containsNode, +selectAllChildren, +extend, +getRangeAt, +removeAllRanges, +addRange, +modify, +setBaseAndExtent, +setPosition, +empty, +getAnchorNode, +getAnchorOffset, +getFocusNode, +getFocusOffset, +getIsCollapsed, +getRangeCount, +getBaseNode, +getBaseOffset, +getExtentNode, +getExtentOffset, +Selection, +castToSelection, +gTypeSelection, +SelectionClass, +toSelection, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures +import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + + +collapse :: + (MonadIO m, SelectionClass self, NodeClass node) => + self -> Maybe node -> Int -> m () +collapse self node index + = liftIO + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_dom_selection_collapse #} (toSelection self) + (maybe (Node nullForeignPtr) toNode node) + (fromIntegral index) + errorPtr_) + +collapseToEnd :: (MonadIO m, SelectionClass self) => self -> m () +collapseToEnd self + = liftIO + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_dom_selection_collapse_to_end #} + (toSelection self) + errorPtr_) + +collapseToStart :: (MonadIO m, SelectionClass self) => self -> m () +collapseToStart self + = liftIO + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_dom_selection_collapse_to_start #} + (toSelection self) + errorPtr_) + +deleteFromDocument :: + (MonadIO m, SelectionClass self) => self -> m () +deleteFromDocument self + = liftIO + ({# call webkit_dom_dom_selection_delete_from_document #} + (toSelection self)) + +containsNode :: + (MonadIO m, SelectionClass self, NodeClass node) => + self -> Maybe node -> Bool -> m Bool +containsNode self node allowPartial + = liftIO + (toBool <$> + ({# call webkit_dom_dom_selection_contains_node #} + (toSelection self) + (maybe (Node nullForeignPtr) toNode node) + (fromBool allowPartial))) + +selectAllChildren :: + (MonadIO m, SelectionClass self, NodeClass node) => + self -> Maybe node -> m () +selectAllChildren self node + = liftIO + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_dom_selection_select_all_children #} + (toSelection self) + (maybe (Node nullForeignPtr) toNode node) + errorPtr_) + +extend :: + (MonadIO m, SelectionClass self, NodeClass node) => + self -> Maybe node -> Int -> m () +extend self node offset + = liftIO + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_dom_selection_extend #} (toSelection self) + (maybe (Node nullForeignPtr) toNode node) + (fromIntegral offset) + errorPtr_) + +getRangeAt :: + (MonadIO m, SelectionClass self) => self -> Int -> m (Maybe Range) +getRangeAt self index + = liftIO + (maybeNull (makeNewGObject mkRange) + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_dom_selection_get_range_at #} (toSelection self) + (fromIntegral index) + errorPtr_)) + +removeAllRanges :: (MonadIO m, SelectionClass self) => self -> m () +removeAllRanges self + = liftIO + ({# call webkit_dom_dom_selection_remove_all_ranges #} + (toSelection self)) + +addRange :: + (MonadIO m, SelectionClass self, RangeClass range) => + self -> Maybe range -> m () +addRange self range + = liftIO + ({# call webkit_dom_dom_selection_add_range #} (toSelection self) + (maybe (Range nullForeignPtr) toRange range)) + +modify :: + (MonadIO m, SelectionClass self, GlibString string) => + self -> string -> string -> string -> m () +modify self alter direction granularity + = liftIO + (withUTFString granularity $ + \ granularityPtr -> + withUTFString direction $ + \ directionPtr -> + withUTFString alter $ + \ alterPtr -> + {# call webkit_dom_dom_selection_modify #} (toSelection self) + alterPtr + directionPtr + granularityPtr) + +setBaseAndExtent :: + (MonadIO m, SelectionClass self, NodeClass baseNode, + NodeClass extentNode) => + self -> Maybe baseNode -> Int -> Maybe extentNode -> Int -> m () +setBaseAndExtent self baseNode baseOffset extentNode extentOffset + = liftIO + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_dom_selection_set_base_and_extent #} + (toSelection self) + (maybe (Node nullForeignPtr) toNode baseNode) + (fromIntegral baseOffset) + (maybe (Node nullForeignPtr) toNode extentNode) + (fromIntegral extentOffset) + errorPtr_) + +setPosition :: + (MonadIO m, SelectionClass self, NodeClass node) => + self -> Maybe node -> Int -> m () +setPosition self node offset + = liftIO + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_dom_selection_set_position #} (toSelection self) + (maybe (Node nullForeignPtr) toNode node) + (fromIntegral offset) + errorPtr_) + +empty :: (MonadIO m, SelectionClass self) => self -> m () +empty self + = liftIO + ({# call webkit_dom_dom_selection_empty #} (toSelection self)) + +getAnchorNode :: + (MonadIO m, SelectionClass self) => self -> m (Maybe Node) +getAnchorNode self + = liftIO + (maybeNull (makeNewGObject mkNode) + ({# call webkit_dom_dom_selection_get_anchor_node #} + (toSelection self))) + +getAnchorOffset :: + (MonadIO m, SelectionClass self) => self -> m Int +getAnchorOffset self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_dom_selection_get_anchor_offset #} + (toSelection self))) + +getFocusNode :: + (MonadIO m, SelectionClass self) => self -> m (Maybe Node) +getFocusNode self + = liftIO + (maybeNull (makeNewGObject mkNode) + ({# call webkit_dom_dom_selection_get_focus_node #} + (toSelection self))) + +getFocusOffset :: (MonadIO m, SelectionClass self) => self -> m Int +getFocusOffset self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_dom_selection_get_focus_offset #} + (toSelection self))) + +getIsCollapsed :: + (MonadIO m, SelectionClass self) => self -> m Bool +getIsCollapsed self + = liftIO + (toBool <$> + ({# call webkit_dom_dom_selection_get_is_collapsed #} + (toSelection self))) + +getRangeCount :: (MonadIO m, SelectionClass self) => self -> m Int +getRangeCount self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_dom_selection_get_range_count #} + (toSelection self))) + +getBaseNode :: + (MonadIO m, SelectionClass self) => self -> m (Maybe Node) +getBaseNode self + = liftIO + (maybeNull (makeNewGObject mkNode) + ({# call webkit_dom_dom_selection_get_base_node #} + (toSelection self))) + +getBaseOffset :: (MonadIO m, SelectionClass self) => self -> m Int +getBaseOffset self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_dom_selection_get_base_offset #} + (toSelection self))) + +getExtentNode :: + (MonadIO m, SelectionClass self) => self -> m (Maybe Node) +getExtentNode self + = liftIO + (maybeNull (makeNewGObject mkNode) + ({# call webkit_dom_dom_selection_get_extent_node #} + (toSelection self))) + +getExtentOffset :: + (MonadIO m, SelectionClass self) => self -> m Int +getExtentOffset self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_dom_selection_get_extent_offset #} + (toSelection self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/Storage.chs b/Graphics/UI/Gtk/WebKit/DOM/Storage.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/Storage.chs @@ -0,0 +1,105 @@ +module Graphics.UI.Gtk.WebKit.DOM.Storage( +#if WEBKIT_CHECK_VERSION(2,2,2) +key, +getItem, +#endif +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 + + +#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_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_) + +#if WEBKIT_CHECK_VERSION(2,2,2) +removeItem :: + (MonadIO m, StorageClass self, GlibString string) => + self -> string -> m () +removeItem self key + = liftIO + (propagateGError $ + \ errorPtr_ -> + withUTFString key $ + \ keyPtr -> + {# call webkit_dom_storage_remove_item #} (toStorage self) keyPtr + errorPtr_) + +clear :: (MonadIO m, StorageClass self) => self -> m () +clear self + = liftIO + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_storage_clear #} (toStorage self) errorPtr_) + +getLength :: (MonadIO m, StorageClass self) => self -> m Word +getLength self + = liftIO + (fromIntegral <$> + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_storage_get_length #} (toStorage self) + errorPtr_)) +#endif diff --git a/Graphics/UI/Gtk/WebKit/DOM/StorageInfo.chs b/Graphics/UI/Gtk/WebKit/DOM/StorageInfo.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/StorageInfo.chs @@ -0,0 +1,29 @@ +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 +#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 TEMPORARY = 0 +pattern PERSISTENT = 1 +#endif diff --git a/Graphics/UI/Gtk/WebKit/DOM/StyleMedia.chs b/Graphics/UI/Gtk/WebKit/DOM/StyleMedia.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/StyleMedia.chs @@ -0,0 +1,33 @@ +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 + + +matchMedium :: + (MonadIO m, StyleMediaClass self, GlibString string) => + self -> string -> m Bool +matchMedium self mediaquery + = liftIO + (toBool <$> + (withUTFString mediaquery $ + \ mediaqueryPtr -> + {# call webkit_dom_style_media_match_medium #} (toStyleMedia self) + mediaqueryPtr)) diff --git a/Graphics/UI/Gtk/WebKit/DOM/StyleSheet.chs b/Graphics/UI/Gtk/WebKit/DOM/StyleSheet.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/StyleSheet.chs @@ -0,0 +1,83 @@ +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 + + +setDisabled :: + (MonadIO m, StyleSheetClass self) => self -> Bool -> m () +setDisabled self val + = liftIO + ({# call webkit_dom_style_sheet_set_disabled #} (toStyleSheet self) + (fromBool val)) + +getDisabled :: (MonadIO m, StyleSheetClass self) => self -> m Bool +getDisabled self + = liftIO + (toBool <$> + ({# call webkit_dom_style_sheet_get_disabled #} + (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))) + +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))) + +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) + +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) + +getMedia :: + (MonadIO m, StyleSheetClass self) => self -> m (Maybe MediaList) +getMedia self + = liftIO + (maybeNull (makeNewGObject mkMediaList) + ({# call webkit_dom_style_sheet_get_media #} (toStyleSheet self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/StyleSheetList.chs b/Graphics/UI/Gtk/WebKit/DOM/StyleSheetList.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/StyleSheetList.chs @@ -0,0 +1,41 @@ +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 + + +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))) + +getLength :: + (MonadIO m, StyleSheetListClass self) => self -> m Word +getLength self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_style_sheet_list_get_length #} + (toStyleSheetList self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/Text.chs b/Graphics/UI/Gtk/WebKit/DOM/Text.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/Text.chs @@ -0,0 +1,56 @@ +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 + + +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_)) + +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_)) + +getWholeText :: + (MonadIO m, TextClass self, GlibString string) => self -> m string +getWholeText self + = liftIO + (({# call webkit_dom_text_get_whole_text #} (toText self)) >>= + readUTFString) diff --git a/Graphics/UI/Gtk/WebKit/DOM/TextTrack.chs b/Graphics/UI/Gtk/WebKit/DOM/TextTrack.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/TextTrack.chs @@ -0,0 +1,136 @@ +module Graphics.UI.Gtk.WebKit.DOM.TextTrack( +#if WEBKIT_CHECK_VERSION(2,2,2) +#if WEBKIT_CHECK_VERSION(2,7,0) +addCue, +#endif +removeCue, +#if WEBKIT_CHECK_VERSION(2,4,0) +getId, +#endif +getLabel, +#if WEBKIT_CHECK_VERSION(99,0,0) +getInBandMetadataTrackDispatchType, +#endif +setMode, +getMode, +getCues, +getActiveCues, +cueChange, +TextTrack, +castToTextTrack, +gTypeTextTrack, +TextTrackClass, +toTextTrack, +#endif +) where +#if WEBKIT_CHECK_VERSION(2,2,2) +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures +import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + + +#if WEBKIT_CHECK_VERSION(2,7,0) +addCue :: + (MonadIO m, TextTrackClass self, TextTrackCueClass cue) => + self -> Maybe cue -> m () +addCue self cue + = liftIO + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_webkit_dom_text_track_add_cue_with_error #} + (toTextTrack self) + (maybe (TextTrackCue nullForeignPtr) toTextTrackCue cue) + errorPtr_) +#endif + +removeCue :: + (MonadIO m, TextTrackClass self, TextTrackCueClass cue) => + self -> Maybe cue -> m () +removeCue self cue + = liftIO + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_text_track_remove_cue #} (toTextTrack self) + (maybe (TextTrackCue nullForeignPtr) toTextTrackCue cue) + errorPtr_) + +#if WEBKIT_CHECK_VERSION(2,4,0) +getId :: + (MonadIO m, TextTrackClass self, GlibString string) => + self -> m string +getId self + = liftIO + (({# call webkit_dom_text_track_get_id #} (toTextTrack self)) >>= + readUTFString) +#endif + +getLabel :: + (MonadIO m, TextTrackClass self, GlibString string) => + self -> m string +getLabel self + = liftIO + (({# call webkit_dom_text_track_get_label #} (toTextTrack self)) + >>= + readUTFString) + +#if WEBKIT_CHECK_VERSION(99,0,0) +getInBandMetadataTrackDispatchType :: + (MonadIO m, TextTrackClass self, GlibString string) => + self -> m string +getInBandMetadataTrackDispatchType self + = liftIO + (({# call + webkit_dom_text_track_get_in_band_metadata_track_dispatch_type + #} + (toTextTrack self)) + >>= + readUTFString) +#endif + +setMode :: + (MonadIO m, TextTrackClass self) => self -> TextTrackMode -> m () +setMode self val + = liftIO + (withUTFString (enumToString val) $ + \ valPtr -> + {# call webkit_dom_text_track_set_mode #} (toTextTrack self) + valPtr) + +getMode :: + (MonadIO m, TextTrackClass self) => self -> m TextTrackMode +getMode self + = liftIO + (stringToEnum <$> + (({# call webkit_dom_text_track_get_mode #} (toTextTrack self)) >>= + readUTFString)) + +getCues :: + (MonadIO m, TextTrackClass self) => + self -> m (Maybe TextTrackCueList) +getCues self + = liftIO + (maybeNull (makeNewGObject mkTextTrackCueList) + ({# call webkit_dom_text_track_get_cues #} (toTextTrack self))) + +getActiveCues :: + (MonadIO m, TextTrackClass self) => + self -> m (Maybe TextTrackCueList) +getActiveCues self + = liftIO + (maybeNull (makeNewGObject mkTextTrackCueList) + ({# call webkit_dom_text_track_get_active_cues #} + (toTextTrack self))) + +cueChange :: (TextTrackClass self) => EventName self Event +cueChange = EventName "cuechange" +#endif diff --git a/Graphics/UI/Gtk/WebKit/DOM/TextTrackCue.chs b/Graphics/UI/Gtk/WebKit/DOM/TextTrackCue.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/TextTrackCue.chs @@ -0,0 +1,124 @@ +module Graphics.UI.Gtk.WebKit.DOM.TextTrackCue( +#if WEBKIT_CHECK_VERSION(2,2,2) +getTrack, +setId, +getId, +setStartTime, +getStartTime, +setEndTime, +getEndTime, +setPauseOnExit, +getPauseOnExit, +enter, +exit, +TextTrackCue, +castToTextTrackCue, +gTypeTextTrackCue, +TextTrackCueClass, +toTextTrackCue, +#endif +) where +#if WEBKIT_CHECK_VERSION(2,2,2) +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures +import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + + +getTrack :: + (MonadIO m, TextTrackCueClass self) => self -> m (Maybe TextTrack) +getTrack self + = liftIO + (maybeNull (makeNewGObject mkTextTrack) + ({# call webkit_dom_text_track_cue_get_track #} + (toTextTrackCue self))) + +setId :: + (MonadIO m, TextTrackCueClass self, GlibString string) => + self -> string -> m () +setId self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_text_track_cue_set_id #} (toTextTrackCue self) + valPtr) + +getId :: + (MonadIO m, TextTrackCueClass self, GlibString string) => + self -> m string +getId self + = liftIO + (({# call webkit_dom_text_track_cue_get_id #} + (toTextTrackCue self)) + >>= + readUTFString) + +setStartTime :: + (MonadIO m, TextTrackCueClass self) => self -> Double -> m () +setStartTime self val + = liftIO + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_text_track_cue_set_start_time #} + (toTextTrackCue self) + (realToFrac val) + errorPtr_) + +getStartTime :: + (MonadIO m, TextTrackCueClass self) => self -> m Double +getStartTime self + = liftIO + (realToFrac <$> + ({# call webkit_dom_text_track_cue_get_start_time #} + (toTextTrackCue self))) + +setEndTime :: + (MonadIO m, TextTrackCueClass self) => self -> Double -> m () +setEndTime self val + = liftIO + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_text_track_cue_set_end_time #} + (toTextTrackCue self) + (realToFrac val) + errorPtr_) + +getEndTime :: + (MonadIO m, TextTrackCueClass self) => self -> m Double +getEndTime self + = liftIO + (realToFrac <$> + ({# call webkit_dom_text_track_cue_get_end_time #} + (toTextTrackCue self))) + +setPauseOnExit :: + (MonadIO m, TextTrackCueClass self) => self -> Bool -> m () +setPauseOnExit self val + = liftIO + ({# call webkit_dom_text_track_cue_set_pause_on_exit #} + (toTextTrackCue self) + (fromBool val)) + +getPauseOnExit :: + (MonadIO m, TextTrackCueClass self) => self -> m Bool +getPauseOnExit self + = liftIO + (toBool <$> + ({# call webkit_dom_text_track_cue_get_pause_on_exit #} + (toTextTrackCue self))) + +enter :: (TextTrackCueClass self) => EventName self Event +enter = EventName "enter" + +exit :: (TextTrackCueClass self) => EventName self Event +exit = EventName "exit" +#endif diff --git a/Graphics/UI/Gtk/WebKit/DOM/TextTrackCueList.chs b/Graphics/UI/Gtk/WebKit/DOM/TextTrackCueList.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/TextTrackCueList.chs @@ -0,0 +1,58 @@ +module Graphics.UI.Gtk.WebKit.DOM.TextTrackCueList( +#if WEBKIT_CHECK_VERSION(2,2,2) +item, +getCueById, +getLength, +TextTrackCueList, +castToTextTrackCueList, +gTypeTextTrackCueList, +TextTrackCueListClass, +toTextTrackCueList, +#endif +) where +#if WEBKIT_CHECK_VERSION(2,2,2) +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures +import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + + +item :: + (MonadIO m, TextTrackCueListClass self) => + self -> Word -> m (Maybe TextTrackCue) +item self index + = liftIO + (maybeNull (makeNewGObject mkTextTrackCue) + ({# call webkit_dom_text_track_cue_list_item #} + (toTextTrackCueList self) + (fromIntegral index))) + +getCueById :: + (MonadIO m, TextTrackCueListClass self, GlibString string) => + self -> string -> m (Maybe TextTrackCue) +getCueById self id + = liftIO + (maybeNull (makeNewGObject mkTextTrackCue) + (withUTFString id $ + \ idPtr -> + {# call webkit_dom_text_track_cue_list_get_cue_by_id #} + (toTextTrackCueList self) + idPtr)) + +getLength :: + (MonadIO m, TextTrackCueListClass self) => self -> m Word +getLength self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_text_track_cue_list_get_length #} + (toTextTrackCueList self))) +#endif diff --git a/Graphics/UI/Gtk/WebKit/DOM/TextTrackList.chs b/Graphics/UI/Gtk/WebKit/DOM/TextTrackList.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/TextTrackList.chs @@ -0,0 +1,72 @@ +module Graphics.UI.Gtk.WebKit.DOM.TextTrackList( +#if WEBKIT_CHECK_VERSION(2,2,2) +item, +#if WEBKIT_CHECK_VERSION(2,4,0) +getTrackById, +#endif +getLength, +addTrack, +change, +removeTrack, +TextTrackList, +castToTextTrackList, +gTypeTextTrackList, +TextTrackListClass, +toTextTrackList, +#endif +) where +#if WEBKIT_CHECK_VERSION(2,2,2) +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures +import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + + +item :: + (MonadIO m, TextTrackListClass self) => + self -> Word -> m (Maybe TextTrack) +item self index + = liftIO + (maybeNull (makeNewGObject mkTextTrack) + ({# call webkit_dom_text_track_list_item #} (toTextTrackList self) + (fromIntegral index))) + +#if WEBKIT_CHECK_VERSION(2,4,0) +getTrackById :: + (MonadIO m, TextTrackListClass self, GlibString string) => + self -> string -> m (Maybe TextTrack) +getTrackById self id + = liftIO + (maybeNull (makeNewGObject mkTextTrack) + (withUTFString id $ + \ idPtr -> + {# call webkit_dom_text_track_list_get_track_by_id #} + (toTextTrackList self) + idPtr)) +#endif + +getLength :: (MonadIO m, TextTrackListClass self) => self -> m Word +getLength self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_text_track_list_get_length #} + (toTextTrackList self))) + +addTrack :: (TextTrackListClass self) => EventName self Event +addTrack = EventName "addtrack" + +change :: (TextTrackListClass self) => EventName self Event +change = EventName "change" + +removeTrack :: (TextTrackListClass self) => EventName self Event +removeTrack = EventName "removetrack" +#endif diff --git a/Graphics/UI/Gtk/WebKit/DOM/TimeRanges.chs b/Graphics/UI/Gtk/WebKit/DOM/TimeRanges.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/TimeRanges.chs @@ -0,0 +1,52 @@ +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 + + +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_)) + +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_)) + +getLength :: (MonadIO m, TimeRangesClass self) => self -> m Word +getLength self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_time_ranges_get_length #} (toTimeRanges self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/Touch.chs b/Graphics/UI/Gtk/WebKit/DOM/Touch.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/Touch.chs @@ -0,0 +1,112 @@ +module Graphics.UI.Gtk.WebKit.DOM.Touch( +#if WEBKIT_CHECK_VERSION(2,4,0) +getClientX, +getClientY, +getScreenX, +getScreenY, +getPageX, +getPageY, +getTarget, +getIdentifier, +getWebkitRadiusX, +getWebkitRadiusY, +getWebkitRotationAngle, +getWebkitForce, +Touch, +castToTouch, +gTypeTouch, +TouchClass, +toTouch, +#endif +) where +#if WEBKIT_CHECK_VERSION(2,4,0) +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures +import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + + +getClientX :: (MonadIO m, TouchClass self) => self -> m Int +getClientX self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_touch_get_client_x #} (toTouch self))) + +getClientY :: (MonadIO m, TouchClass self) => self -> m Int +getClientY self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_touch_get_client_y #} (toTouch self))) + +getScreenX :: (MonadIO m, TouchClass self) => self -> m Int +getScreenX self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_touch_get_screen_x #} (toTouch self))) + +getScreenY :: (MonadIO m, TouchClass self) => self -> m Int +getScreenY self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_touch_get_screen_y #} (toTouch self))) + +getPageX :: (MonadIO m, TouchClass self) => self -> m Int +getPageX self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_touch_get_page_x #} (toTouch self))) + +getPageY :: (MonadIO m, TouchClass self) => self -> m Int +getPageY self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_touch_get_page_y #} (toTouch self))) + +getTarget :: + (MonadIO m, TouchClass self) => self -> m (Maybe EventTarget) +getTarget self + = liftIO + (maybeNull (makeNewGObject mkEventTarget) + ({# call webkit_dom_touch_get_target #} (toTouch self))) + +getIdentifier :: (MonadIO m, TouchClass self) => self -> m Word +getIdentifier self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_touch_get_identifier #} (toTouch self))) + +getWebkitRadiusX :: (MonadIO m, TouchClass self) => self -> m Int +getWebkitRadiusX self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_touch_get_webkit_radius_x #} (toTouch self))) + +getWebkitRadiusY :: (MonadIO m, TouchClass self) => self -> m Int +getWebkitRadiusY self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_touch_get_webkit_radius_y #} (toTouch self))) + +getWebkitRotationAngle :: + (MonadIO m, TouchClass self) => self -> m Float +getWebkitRotationAngle self + = liftIO + (realToFrac <$> + ({# call webkit_dom_touch_get_webkit_rotation_angle #} + (toTouch self))) + +getWebkitForce :: (MonadIO m, TouchClass self) => self -> m Float +getWebkitForce self + = liftIO + (realToFrac <$> + ({# call webkit_dom_touch_get_webkit_force #} (toTouch self))) +#endif diff --git a/Graphics/UI/Gtk/WebKit/DOM/TreeWalker.chs b/Graphics/UI/Gtk/WebKit/DOM/TreeWalker.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/TreeWalker.chs @@ -0,0 +1,77 @@ +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 + + +getRoot :: + (MonadIO m, TreeWalkerClass self) => self -> m (Maybe Node) +getRoot self + = liftIO + (maybeNull (makeNewGObject mkNode) + ({# call webkit_dom_tree_walker_get_root #} (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))) + +getFilter :: + (MonadIO m, TreeWalkerClass self) => self -> m (Maybe NodeFilter) +getFilter self + = liftIO + (maybeNull (makeNewGObject mkNodeFilter) + ({# call webkit_dom_tree_walker_get_filter #} (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))) + +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_) + +getCurrentNode :: + (MonadIO m, TreeWalkerClass self) => self -> m (Maybe Node) +getCurrentNode self + = liftIO + (maybeNull (makeNewGObject mkNode) + ({# call webkit_dom_tree_walker_get_current_node #} + (toTreeWalker self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/UIEvent.chs b/Graphics/UI/Gtk/WebKit/DOM/UIEvent.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/UIEvent.chs @@ -0,0 +1,100 @@ +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 + + +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)) + +getView :: + (MonadIO m, UIEventClass self) => self -> m (Maybe Window) +getView self + = liftIO + (maybeNull (makeNewGObject mkWindow) + ({# call webkit_dom_ui_event_get_view #} (toUIEvent self))) + +getDetail :: (MonadIO m, UIEventClass self) => self -> m Int +getDetail self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_ui_event_get_detail #} (toUIEvent self))) + +getKeyCode :: (MonadIO m, UIEventClass self) => self -> m Int +getKeyCode self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_ui_event_get_key_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))) + +getLayerX :: (MonadIO m, UIEventClass self) => self -> m Int +getLayerX self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_ui_event_get_layer_x #} (toUIEvent self))) + +getLayerY :: (MonadIO m, UIEventClass self) => self -> m Int +getLayerY self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_ui_event_get_layer_y #} (toUIEvent self))) + +getPageX :: (MonadIO m, UIEventClass self) => self -> m Int +getPageX self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_ui_event_get_page_x #} (toUIEvent self))) + +getPageY :: (MonadIO m, UIEventClass self) => self -> m Int +getPageY self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_ui_event_get_page_y #} (toUIEvent self))) + +getWhich :: (MonadIO m, UIEventClass self) => self -> m Int +getWhich self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_ui_event_get_which #} (toUIEvent self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/ValidityState.chs b/Graphics/UI/Gtk/WebKit/DOM/ValidityState.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/ValidityState.chs @@ -0,0 +1,114 @@ +module Graphics.UI.Gtk.WebKit.DOM.ValidityState( +getValueMissing, +getTypeMismatch, +getPatternMismatch, +getTooLong, +getRangeUnderflow, +getRangeOverflow, +getStepMismatch, +#if WEBKIT_CHECK_VERSION(2,2,2) +getBadInput, +#endif +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 +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + + +getValueMissing :: + (MonadIO m, ValidityStateClass self) => self -> m Bool +getValueMissing self + = liftIO + (toBool <$> + ({# call webkit_dom_validity_state_get_value_missing #} + (toValidityState self))) + +getTypeMismatch :: + (MonadIO m, ValidityStateClass self) => self -> m Bool +getTypeMismatch self + = liftIO + (toBool <$> + ({# call webkit_dom_validity_state_get_type_mismatch #} + (toValidityState self))) + +getPatternMismatch :: + (MonadIO m, ValidityStateClass self) => self -> m Bool +getPatternMismatch self + = liftIO + (toBool <$> + ({# call webkit_dom_validity_state_get_pattern_mismatch #} + (toValidityState self))) + +getTooLong :: + (MonadIO m, ValidityStateClass self) => self -> m Bool +getTooLong self + = liftIO + (toBool <$> + ({# call webkit_dom_validity_state_get_too_long #} + (toValidityState self))) + +getRangeUnderflow :: + (MonadIO m, ValidityStateClass self) => self -> m Bool +getRangeUnderflow self + = liftIO + (toBool <$> + ({# call webkit_dom_validity_state_get_range_underflow #} + (toValidityState self))) + +getRangeOverflow :: + (MonadIO m, ValidityStateClass self) => self -> m Bool +getRangeOverflow self + = liftIO + (toBool <$> + ({# call webkit_dom_validity_state_get_range_overflow #} + (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 + +getCustomError :: + (MonadIO m, ValidityStateClass self) => self -> m Bool +getCustomError self + = liftIO + (toBool <$> + ({# call webkit_dom_validity_state_get_custom_error #} + (toValidityState self))) + +getValid :: (MonadIO m, ValidityStateClass self) => self -> m Bool +getValid self + = liftIO + (toBool <$> + ({# call webkit_dom_validity_state_get_valid #} + (toValidityState self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/VideoTrack.chs b/Graphics/UI/Gtk/WebKit/DOM/VideoTrack.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/VideoTrack.chs @@ -0,0 +1,60 @@ +module Graphics.UI.Gtk.WebKit.DOM.VideoTrack( +#if WEBKIT_CHECK_VERSION(2,2,2) +getId, +getLabel, +setSelected, +getSelected, +VideoTrack, +castToVideoTrack, +gTypeVideoTrack, +VideoTrackClass, +toVideoTrack, +#endif +) where +#if WEBKIT_CHECK_VERSION(2,2,2) +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures +import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + + +getId :: + (MonadIO m, VideoTrackClass self, GlibString string) => + self -> m string +getId self + = liftIO + (({# call webkit_dom_video_track_get_id #} (toVideoTrack self)) >>= + readUTFString) + +getLabel :: + (MonadIO m, VideoTrackClass self, GlibString string) => + self -> m string +getLabel self + = liftIO + (({# call webkit_dom_video_track_get_label #} (toVideoTrack self)) + >>= + readUTFString) + +setSelected :: + (MonadIO m, VideoTrackClass self) => self -> Bool -> m () +setSelected self val + = liftIO + ({# call webkit_dom_video_track_set_selected #} (toVideoTrack self) + (fromBool val)) + +getSelected :: (MonadIO m, VideoTrackClass self) => self -> m Bool +getSelected self + = liftIO + (toBool <$> + ({# call webkit_dom_video_track_get_selected #} + (toVideoTrack self))) +#endif diff --git a/Graphics/UI/Gtk/WebKit/DOM/VideoTrackList.chs b/Graphics/UI/Gtk/WebKit/DOM/VideoTrackList.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/VideoTrackList.chs @@ -0,0 +1,83 @@ +module Graphics.UI.Gtk.WebKit.DOM.VideoTrackList( +#if WEBKIT_CHECK_VERSION(2,2,2) +item, +getTrackById, +getLength, +#if WEBKIT_CHECK_VERSION(99,0,0) +getSelectedIndex, +#endif +change, +addTrack, +removeTrack, +VideoTrackList, +castToVideoTrackList, +gTypeVideoTrackList, +VideoTrackListClass, +toVideoTrackList, +#endif +) where +#if WEBKIT_CHECK_VERSION(2,2,2) +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures +import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + + +item :: + (MonadIO m, VideoTrackListClass self) => + self -> Word -> m (Maybe VideoTrack) +item self index + = liftIO + (maybeNull (makeNewGObject mkVideoTrack) + ({# call webkit_dom_video_track_list_item #} + (toVideoTrackList self) + (fromIntegral index))) + +getTrackById :: + (MonadIO m, VideoTrackListClass self, GlibString string) => + self -> string -> m (Maybe VideoTrack) +getTrackById self id + = liftIO + (maybeNull (makeNewGObject mkVideoTrack) + (withUTFString id $ + \ idPtr -> + {# call webkit_dom_video_track_list_get_track_by_id #} + (toVideoTrackList self) + idPtr)) + +getLength :: + (MonadIO m, VideoTrackListClass self) => self -> m Word +getLength self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_video_track_list_get_length #} + (toVideoTrackList self))) + +#if WEBKIT_CHECK_VERSION(99,0,0) +getSelectedIndex :: + (MonadIO m, VideoTrackListClass self) => self -> m Int +getSelectedIndex self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_video_track_list_get_selected_index #} + (toVideoTrackList self))) +#endif + +change :: (VideoTrackListClass self) => EventName self Event +change = EventName "change" + +addTrack :: (VideoTrackListClass self) => EventName self Event +addTrack = EventName "addtrack" + +removeTrack :: (VideoTrackListClass self) => EventName self Event +removeTrack = EventName "removetrack" +#endif diff --git a/Graphics/UI/Gtk/WebKit/DOM/WebKitNamedFlow.chs b/Graphics/UI/Gtk/WebKit/DOM/WebKitNamedFlow.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/WebKitNamedFlow.chs @@ -0,0 +1,86 @@ +module Graphics.UI.Gtk.WebKit.DOM.WebKitNamedFlow( +#if WEBKIT_CHECK_VERSION(2,2,2) +getRegionsByContent, +getRegions, +getContent, +getName, +getOverset, +getFirstEmptyRegionIndex, +#endif +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 +{#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))) + +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))) + +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))) + +getName :: + (MonadIO m, WebKitNamedFlowClass self, GlibString string) => + self -> m string +getName self + = liftIO + (({# call webkit_dom_webkit_named_flow_get_name #} + (toWebKitNamedFlow self)) + >>= + readUTFString) + +getOverset :: + (MonadIO m, WebKitNamedFlowClass self) => self -> m Bool +getOverset self + = liftIO + (toBool <$> + ({# call webkit_dom_webkit_named_flow_get_overset #} + (toWebKitNamedFlow self))) + +getFirstEmptyRegionIndex :: + (MonadIO m, WebKitNamedFlowClass self) => self -> m Int +getFirstEmptyRegionIndex self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_webkit_named_flow_get_first_empty_region_index + #} + (toWebKitNamedFlow self))) +#endif diff --git a/Graphics/UI/Gtk/WebKit/DOM/WebKitPoint.chs b/Graphics/UI/Gtk/WebKit/DOM/WebKitPoint.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/WebKitPoint.chs @@ -0,0 +1,49 @@ +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 + + +setX :: (MonadIO m, WebKitPointClass self) => self -> Float -> m () +setX self val + = liftIO + ({# call webkit_dom_webkit_point_set_x #} (toWebKitPoint self) + (realToFrac val)) + +getX :: (MonadIO m, WebKitPointClass self) => self -> m Float +getX self + = liftIO + (realToFrac <$> + ({# call webkit_dom_webkit_point_get_x #} (toWebKitPoint self))) + +setY :: (MonadIO m, WebKitPointClass self) => self -> Float -> m () +setY self val + = liftIO + ({# call webkit_dom_webkit_point_set_y #} (toWebKitPoint self) + (realToFrac val)) + +getY :: (MonadIO m, WebKitPointClass self) => self -> m Float +getY self + = liftIO + (realToFrac <$> + ({# call webkit_dom_webkit_point_get_y #} (toWebKitPoint self))) diff --git a/Graphics/UI/Gtk/WebKit/DOM/WheelEvent.chs b/Graphics/UI/Gtk/WebKit/DOM/WheelEvent.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/WheelEvent.chs @@ -0,0 +1,125 @@ +module Graphics.UI.Gtk.WebKit.DOM.WheelEvent( +#if WEBKIT_CHECK_VERSION(2,4,0) +initWheelEvent, +pattern DOM_DELTA_PIXEL, +pattern DOM_DELTA_LINE, +pattern DOM_DELTA_PAGE, +getDeltaX, +getDeltaY, +getDeltaZ, +getDeltaMode, +getWheelDeltaX, +getWheelDeltaY, +getWheelDelta, +getWebkitDirectionInvertedFromDevice, +WheelEvent, +castToWheelEvent, +gTypeWheelEvent, +WheelEventClass, +toWheelEvent, +#endif +) where +#if WEBKIT_CHECK_VERSION(2,4,0) +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures +import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + + +initWheelEvent :: + (MonadIO m, WheelEventClass self, WindowClass view) => + self -> + Int -> + Int -> + Maybe view -> + Int -> Int -> Int -> Int -> Bool -> Bool -> Bool -> Bool -> m () +initWheelEvent self wheelDeltaX wheelDeltaY view screenX screenY + clientX clientY ctrlKey altKey shiftKey metaKey + = liftIO + ({# call webkit_dom_wheel_event_init_wheel_event #} + (toWheelEvent self) + (fromIntegral wheelDeltaX) + (fromIntegral wheelDeltaY) + (maybe (Window nullForeignPtr) toWindow view) + (fromIntegral screenX) + (fromIntegral screenY) + (fromIntegral clientX) + (fromIntegral clientY) + (fromBool ctrlKey) + (fromBool altKey) + (fromBool shiftKey) + (fromBool metaKey)) +pattern DOM_DELTA_PIXEL = 0 +pattern DOM_DELTA_LINE = 1 +pattern DOM_DELTA_PAGE = 2 + +getDeltaX :: (MonadIO m, WheelEventClass self) => self -> m Double +getDeltaX self + = liftIO + (realToFrac <$> + ({# call webkit_dom_wheel_event_get_delta_x #} + (toWheelEvent self))) + +getDeltaY :: (MonadIO m, WheelEventClass self) => self -> m Double +getDeltaY self + = liftIO + (realToFrac <$> + ({# call webkit_dom_wheel_event_get_delta_y #} + (toWheelEvent self))) + +getDeltaZ :: (MonadIO m, WheelEventClass self) => self -> m Double +getDeltaZ self + = liftIO + (realToFrac <$> + ({# call webkit_dom_wheel_event_get_delta_z #} + (toWheelEvent self))) + +getDeltaMode :: (MonadIO m, WheelEventClass self) => self -> m Word +getDeltaMode self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_wheel_event_get_delta_mode #} + (toWheelEvent self))) + +getWheelDeltaX :: + (MonadIO m, WheelEventClass self) => self -> m Int +getWheelDeltaX self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_wheel_event_get_wheel_delta_x #} + (toWheelEvent self))) + +getWheelDeltaY :: + (MonadIO m, WheelEventClass self) => self -> m Int +getWheelDeltaY self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_wheel_event_get_wheel_delta_y #} + (toWheelEvent self))) + +getWheelDelta :: (MonadIO m, WheelEventClass self) => self -> m Int +getWheelDelta self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_wheel_event_get_wheel_delta #} + (toWheelEvent self))) + +getWebkitDirectionInvertedFromDevice :: + (MonadIO m, WheelEventClass self) => self -> m Bool +getWebkitDirectionInvertedFromDevice self + = liftIO + (toBool <$> + ({# call + webkit_dom_wheel_event_get_webkit_direction_inverted_from_device + #} + (toWheelEvent self))) +#endif diff --git a/Graphics/UI/Gtk/WebKit/DOM/Window.chs b/Graphics/UI/Gtk/WebKit/DOM/Window.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/Window.chs @@ -0,0 +1,995 @@ +module Graphics.UI.Gtk.WebKit.DOM.Window( +getSelection, +blur, +print, +stop, +alert, +confirm, +prompt, +find, +scrollBy, +scrollTo, +scroll, +moveBy, +moveTo, +resizeBy, +resizeTo, +matchMedia, +getComputedStyle, +webkitConvertPointFromPageToNode, +webkitConvertPointFromNodeToPage, +captureEvents, +releaseEvents, +#if WEBKIT_CHECK_VERSION(2,2,2) +getWebkitStorageInfo, +#endif +getScreen, +getHistory, +#if WEBKIT_CHECK_VERSION(2,2,2) +getLocationbar, +getMenubar, +getPersonalbar, +getScrollbars, +getStatusbar, +getToolbar, +#endif +getNavigator, +getClientInformation, +getFrameElement, +getOffscreenBuffering, +getOuterHeight, +getOuterWidth, +getInnerHeight, +getInnerWidth, +getScreenX, +getScreenY, +getScreenLeft, +getScreenTop, +getScrollX, +getScrollY, +getPageXOffset, +getPageYOffset, +getClosed, +getLength, +setName, +getName, +setStatus, +getStatus, +setDefaultStatus, +getDefaultStatus, +getSelf, +getWindow, +getFrames, +getOpener, +getParent, +getTop, +getDocument, +getStyleMedia, +getDevicePixelRatio, +getApplicationCache, +getSessionStorage, +getLocalStorage, +#if WEBKIT_CHECK_VERSION(2,2,2) +getPerformance, +getCSS, +#endif +abort, +beforeUnload, +blurEvent, +canPlay, +canPlayThrough, +change, +click, +contextMenu, +dblClick, +drag, +dragEnd, +dragEnter, +dragLeave, +dragOver, +dragStart, +drop, +durationChange, +emptied, +ended, +error, +focusEvent, +hashChange, +input, +invalid, +#if WEBKIT_CHECK_VERSION(2,2,2) +keyDown, +keyPress, +keyUp, +#endif +load, +loadedData, +loadedMetadata, +loadStart, +message, +mouseDown, +mouseEnter, +mouseLeave, +mouseMove, +mouseOut, +mouseOver, +mouseUp, +mouseWheel, +offline, +online, +pageHide, +pageShow, +pause, +play, +playing, +popState, +progress, +rateChange, +resize, +scrollEvent, +seeked, +seeking, +select, +stalled, +storage, +submit, +suspend, +timeUpdate, +unload, +volumeChange, +waiting, +#if WEBKIT_CHECK_VERSION(2,4,0) +wheel, +#endif +reset, +search, +webKitAnimationEnd, +webKitAnimationIteration, +webKitAnimationStart, +animationEnd, +animationIteration, +animationStart, +webKitTransitionEnd, +transitionEnd, +touchStart, +touchMove, +touchEnd, +touchCancel, +gestureStart, +gestureChange, +gestureEnd, +deviceMotion, +deviceOrientation, +webKitDeviceProximity, +webKitWillRevealBottom, +webKitWillRevealLeft, +webKitWillRevealRight, +webKitWillRevealTop, +Window, +castToWindow, +gTypeWindow, +WindowClass, +toWindow, +) where +import Prelude hiding (drop, error, print) +import Data.Typeable (Typeable) +import Foreign.Marshal (maybePeek, maybeWith) +import System.Glib.FFI (maybeNull, withForeignPtr, nullForeignPtr, Ptr, nullPtr, castPtr, Word, Int64, Word64, CChar(..), CInt(..), CUInt(..), CLong(..), CULong(..), CLLong(..), CULLong(..), CShort(..), CUShort(..), CFloat(..), CDouble(..), toBool, fromBool) +import System.Glib.UTFString (GlibString(..), readUTFString) +import Control.Applicative ((<$>)) +import Control.Monad (void) +import Control.Monad.IO.Class (MonadIO(..)) +import System.Glib.GError +import Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures +import Graphics.UI.Gtk.WebKit.DOM.EventM +{#import Graphics.UI.Gtk.WebKit.Types#} +import Graphics.UI.Gtk.WebKit.DOM.Enums + + +getSelection :: + (MonadIO m, WindowClass self) => self -> m (Maybe Selection) +getSelection self + = liftIO + (maybeNull (makeNewGObject mkSelection) + ({# call webkit_dom_dom_window_get_selection #} (toWindow self))) + +blur :: (MonadIO m, WindowClass self) => self -> m () +blur self + = liftIO ({# call webkit_dom_dom_window_blur #} (toWindow self)) + +print :: (MonadIO m, WindowClass self) => self -> m () +print self + = liftIO ({# call webkit_dom_dom_window_print #} (toWindow self)) + +stop :: (MonadIO m, WindowClass self) => self -> m () +stop self + = liftIO ({# call webkit_dom_dom_window_stop #} (toWindow self)) + +alert :: + (MonadIO m, WindowClass self, GlibString string) => + self -> string -> m () +alert self message + = liftIO + (withUTFString message $ + \ messagePtr -> + {# call webkit_dom_dom_window_alert #} (toWindow self) messagePtr) + +confirm :: + (MonadIO m, WindowClass self, GlibString string) => + self -> string -> m Bool +confirm self message + = liftIO + (toBool <$> + (withUTFString message $ + \ messagePtr -> + {# call webkit_dom_dom_window_confirm #} (toWindow self) + messagePtr)) + +prompt :: + (MonadIO m, WindowClass self, GlibString string) => + self -> string -> (Maybe string) -> m (Maybe string) +prompt self message defaultValue + = liftIO + ((maybeWith withUTFString defaultValue $ + \ defaultValuePtr -> + withUTFString message $ + \ messagePtr -> + {# call webkit_dom_dom_window_prompt #} (toWindow self) messagePtr + defaultValuePtr) + >>= + maybePeek readUTFString) + +find :: + (MonadIO m, WindowClass self, GlibString string) => + self -> + string -> Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> m Bool +find self string caseSensitive backwards wrap wholeWord + searchInFrames showDialog + = liftIO + (toBool <$> + (withUTFString string $ + \ stringPtr -> + {# call webkit_dom_dom_window_find #} (toWindow self) stringPtr + (fromBool caseSensitive) + (fromBool backwards) + (fromBool wrap) + (fromBool wholeWord) + (fromBool searchInFrames) + (fromBool showDialog))) + +scrollBy :: + (MonadIO m, WindowClass self) => self -> Int -> Int -> m () +scrollBy self x y + = liftIO + ({# call webkit_dom_dom_window_scroll_by #} (toWindow self) + (fromIntegral x) + (fromIntegral y)) + +scrollTo :: + (MonadIO m, WindowClass self) => self -> Int -> Int -> m () +scrollTo self x y + = liftIO + ({# call webkit_dom_dom_window_scroll_to #} (toWindow self) + (fromIntegral x) + (fromIntegral y)) + +scroll :: + (MonadIO m, WindowClass self) => self -> Int -> Int -> m () +scroll self x y + = liftIO + ({# call webkit_dom_dom_window_scroll #} (toWindow self) + (fromIntegral x) + (fromIntegral y)) + +moveBy :: + (MonadIO m, WindowClass self) => self -> Float -> Float -> m () +moveBy self x y + = liftIO + ({# call webkit_dom_dom_window_move_by #} (toWindow self) + (realToFrac x) + (realToFrac y)) + +moveTo :: + (MonadIO m, WindowClass self) => self -> Float -> Float -> m () +moveTo self x y + = liftIO + ({# call webkit_dom_dom_window_move_to #} (toWindow self) + (realToFrac x) + (realToFrac y)) + +resizeBy :: + (MonadIO m, WindowClass self) => self -> Float -> Float -> m () +resizeBy self x y + = liftIO + ({# call webkit_dom_dom_window_resize_by #} (toWindow self) + (realToFrac x) + (realToFrac y)) + +resizeTo :: + (MonadIO m, WindowClass self) => self -> Float -> Float -> m () +resizeTo self width height + = liftIO + ({# call webkit_dom_dom_window_resize_to #} (toWindow self) + (realToFrac width) + (realToFrac height)) + +matchMedia :: + (MonadIO m, WindowClass self, GlibString string) => + self -> string -> m (Maybe MediaQueryList) +matchMedia self query + = liftIO + (maybeNull (makeNewGObject mkMediaQueryList) + (withUTFString query $ + \ queryPtr -> + {# call webkit_dom_dom_window_match_media #} (toWindow self) + queryPtr)) + +getComputedStyle :: + (MonadIO m, WindowClass self, ElementClass element, + GlibString string) => + self -> + Maybe element -> (Maybe string) -> m (Maybe CSSStyleDeclaration) +getComputedStyle self element pseudoElement + = liftIO + (maybeNull (makeNewGObject mkCSSStyleDeclaration) + (maybeWith withUTFString pseudoElement $ + \ pseudoElementPtr -> + {# call webkit_dom_dom_window_get_computed_style #} (toWindow self) + (maybe (Element nullForeignPtr) toElement element) + pseudoElementPtr)) + +webkitConvertPointFromPageToNode :: + (MonadIO m, WindowClass self, NodeClass node, + WebKitPointClass p) => + self -> Maybe node -> Maybe p -> m (Maybe WebKitPoint) +webkitConvertPointFromPageToNode self node p + = liftIO + (maybeNull (makeNewGObject mkWebKitPoint) + ({# call + webkit_dom_dom_window_webkit_convert_point_from_page_to_node + #} + (toWindow self) + (maybe (Node nullForeignPtr) toNode node) + (maybe (WebKitPoint nullForeignPtr) toWebKitPoint p))) + +webkitConvertPointFromNodeToPage :: + (MonadIO m, WindowClass self, NodeClass node, + WebKitPointClass p) => + self -> Maybe node -> Maybe p -> m (Maybe WebKitPoint) +webkitConvertPointFromNodeToPage self node p + = liftIO + (maybeNull (makeNewGObject mkWebKitPoint) + ({# call + webkit_dom_dom_window_webkit_convert_point_from_node_to_page + #} + (toWindow self) + (maybe (Node nullForeignPtr) toNode node) + (maybe (WebKitPoint nullForeignPtr) toWebKitPoint p))) + +captureEvents :: (MonadIO m, WindowClass self) => self -> m () +captureEvents self + = liftIO + ({# call webkit_dom_dom_window_capture_events #} (toWindow self)) + +releaseEvents :: (MonadIO m, WindowClass self) => self -> m () +releaseEvents self + = liftIO + ({# call webkit_dom_dom_window_release_events #} (toWindow self)) + +#if WEBKIT_CHECK_VERSION(2,2,2) +getWebkitStorageInfo :: + (MonadIO m, WindowClass self) => self -> m (Maybe StorageInfo) +getWebkitStorageInfo self + = liftIO + (maybeNull (makeNewGObject mkStorageInfo) + ({# call webkit_dom_dom_window_get_webkit_storage_info #} + (toWindow self))) +#endif + +getScreen :: + (MonadIO m, WindowClass self) => self -> m (Maybe Screen) +getScreen self + = liftIO + (maybeNull (makeNewGObject mkScreen) + ({# call webkit_dom_dom_window_get_screen #} (toWindow self))) + +getHistory :: + (MonadIO m, WindowClass self) => self -> m (Maybe History) +getHistory self + = liftIO + (maybeNull (makeNewGObject mkHistory) + ({# call webkit_dom_dom_window_get_history #} (toWindow self))) + +#if WEBKIT_CHECK_VERSION(2,2,2) +getLocationbar :: + (MonadIO m, WindowClass self) => self -> m (Maybe BarProp) +getLocationbar self + = liftIO + (maybeNull (makeNewGObject mkBarProp) + ({# call webkit_dom_dom_window_get_locationbar #} (toWindow self))) + +getMenubar :: + (MonadIO m, WindowClass self) => self -> m (Maybe BarProp) +getMenubar self + = liftIO + (maybeNull (makeNewGObject mkBarProp) + ({# call webkit_dom_dom_window_get_menubar #} (toWindow self))) + +getPersonalbar :: + (MonadIO m, WindowClass self) => self -> m (Maybe BarProp) +getPersonalbar self + = liftIO + (maybeNull (makeNewGObject mkBarProp) + ({# call webkit_dom_dom_window_get_personalbar #} (toWindow self))) + +getScrollbars :: + (MonadIO m, WindowClass self) => self -> m (Maybe BarProp) +getScrollbars self + = liftIO + (maybeNull (makeNewGObject mkBarProp) + ({# call webkit_dom_dom_window_get_scrollbars #} (toWindow self))) + +getStatusbar :: + (MonadIO m, WindowClass self) => self -> m (Maybe BarProp) +getStatusbar self + = liftIO + (maybeNull (makeNewGObject mkBarProp) + ({# call webkit_dom_dom_window_get_statusbar #} (toWindow self))) + +getToolbar :: + (MonadIO m, WindowClass self) => self -> m (Maybe BarProp) +getToolbar self + = liftIO + (maybeNull (makeNewGObject mkBarProp) + ({# call webkit_dom_dom_window_get_toolbar #} (toWindow self))) +#endif + +getNavigator :: + (MonadIO m, WindowClass self) => self -> m (Maybe Navigator) +getNavigator self + = liftIO + (maybeNull (makeNewGObject mkNavigator) + ({# call webkit_dom_dom_window_get_navigator #} (toWindow self))) + +getClientInformation :: + (MonadIO m, WindowClass self) => self -> m (Maybe Navigator) +getClientInformation self + = liftIO + (maybeNull (makeNewGObject mkNavigator) + ({# call webkit_dom_dom_window_get_client_information #} + (toWindow self))) + +getFrameElement :: + (MonadIO m, WindowClass self) => self -> m (Maybe Element) +getFrameElement self + = liftIO + (maybeNull (makeNewGObject mkElement) + ({# call webkit_dom_dom_window_get_frame_element #} + (toWindow self))) + +getOffscreenBuffering :: + (MonadIO m, WindowClass self) => self -> m Bool +getOffscreenBuffering self + = liftIO + (toBool <$> + ({# call webkit_dom_dom_window_get_offscreen_buffering #} + (toWindow self))) + +getOuterHeight :: (MonadIO m, WindowClass self) => self -> m Int +getOuterHeight self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_dom_window_get_outer_height #} + (toWindow self))) + +getOuterWidth :: (MonadIO m, WindowClass self) => self -> m Int +getOuterWidth self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_dom_window_get_outer_width #} (toWindow self))) + +getInnerHeight :: (MonadIO m, WindowClass self) => self -> m Int +getInnerHeight self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_dom_window_get_inner_height #} + (toWindow self))) + +getInnerWidth :: (MonadIO m, WindowClass self) => self -> m Int +getInnerWidth self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_dom_window_get_inner_width #} (toWindow self))) + +getScreenX :: (MonadIO m, WindowClass self) => self -> m Int +getScreenX self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_dom_window_get_screen_x #} (toWindow self))) + +getScreenY :: (MonadIO m, WindowClass self) => self -> m Int +getScreenY self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_dom_window_get_screen_y #} (toWindow self))) + +getScreenLeft :: (MonadIO m, WindowClass self) => self -> m Int +getScreenLeft self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_dom_window_get_screen_left #} (toWindow self))) + +getScreenTop :: (MonadIO m, WindowClass self) => self -> m Int +getScreenTop self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_dom_window_get_screen_top #} (toWindow self))) + +getScrollX :: (MonadIO m, WindowClass self) => self -> m Int +getScrollX self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_dom_window_get_scroll_x #} (toWindow self))) + +getScrollY :: (MonadIO m, WindowClass self) => self -> m Int +getScrollY self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_dom_window_get_scroll_y #} (toWindow self))) + +getPageXOffset :: (MonadIO m, WindowClass self) => self -> m Int +getPageXOffset self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_dom_window_get_page_x_offset #} + (toWindow self))) + +getPageYOffset :: (MonadIO m, WindowClass self) => self -> m Int +getPageYOffset self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_dom_window_get_page_y_offset #} + (toWindow self))) + +getClosed :: (MonadIO m, WindowClass self) => self -> m Bool +getClosed self + = liftIO + (toBool <$> + ({# call webkit_dom_dom_window_get_closed #} (toWindow self))) + +getLength :: (MonadIO m, WindowClass self) => self -> m Word +getLength self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_dom_window_get_length #} (toWindow self))) + +setName :: + (MonadIO m, WindowClass self, GlibString string) => + self -> string -> m () +setName self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_dom_window_set_name #} (toWindow self) valPtr) + +getName :: + (MonadIO m, WindowClass self, GlibString string) => + self -> m string +getName self + = liftIO + (({# call webkit_dom_dom_window_get_name #} (toWindow self)) >>= + readUTFString) + +setStatus :: + (MonadIO m, WindowClass self, GlibString string) => + self -> string -> m () +setStatus self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_dom_window_set_status #} (toWindow self) valPtr) + +getStatus :: + (MonadIO m, WindowClass self, GlibString string) => + self -> m string +getStatus self + = liftIO + (({# call webkit_dom_dom_window_get_status #} (toWindow self)) >>= + readUTFString) + +setDefaultStatus :: + (MonadIO m, WindowClass self, GlibString string) => + self -> string -> m () +setDefaultStatus self val + = liftIO + (withUTFString val $ + \ valPtr -> + {# call webkit_dom_dom_window_set_default_status #} (toWindow self) + valPtr) + +getDefaultStatus :: + (MonadIO m, WindowClass self, GlibString string) => + self -> m string +getDefaultStatus self + = liftIO + (({# call webkit_dom_dom_window_get_default_status #} + (toWindow self)) + >>= + readUTFString) + +getSelf :: + (MonadIO m, WindowClass self) => self -> m (Maybe Window) +getSelf self + = liftIO + (maybeNull (makeNewGObject mkWindow) + ({# call webkit_dom_dom_window_get_self #} (toWindow self))) + +getWindow :: + (MonadIO m, WindowClass self) => self -> m (Maybe Window) +getWindow self + = liftIO + (maybeNull (makeNewGObject mkWindow) + ({# call webkit_dom_dom_window_get_window #} (toWindow self))) + +getFrames :: + (MonadIO m, WindowClass self) => self -> m (Maybe Window) +getFrames self + = liftIO + (maybeNull (makeNewGObject mkWindow) + ({# call webkit_dom_dom_window_get_frames #} (toWindow self))) + +getOpener :: + (MonadIO m, WindowClass self) => self -> m (Maybe Window) +getOpener self + = liftIO + (maybeNull (makeNewGObject mkWindow) + ({# call webkit_dom_dom_window_get_opener #} (toWindow self))) + +getParent :: + (MonadIO m, WindowClass self) => self -> m (Maybe Window) +getParent self + = liftIO + (maybeNull (makeNewGObject mkWindow) + ({# call webkit_dom_dom_window_get_parent #} (toWindow self))) + +getTop :: (MonadIO m, WindowClass self) => self -> m (Maybe Window) +getTop self + = liftIO + (maybeNull (makeNewGObject mkWindow) + ({# call webkit_dom_dom_window_get_top #} (toWindow self))) + +getDocument :: + (MonadIO m, WindowClass self) => self -> m (Maybe Document) +getDocument self + = liftIO + (maybeNull (makeNewGObject mkDocument) + ({# call webkit_dom_dom_window_get_document #} (toWindow self))) + +getStyleMedia :: + (MonadIO m, WindowClass self) => self -> m (Maybe StyleMedia) +getStyleMedia self + = liftIO + (maybeNull (makeNewGObject mkStyleMedia) + ({# call webkit_dom_dom_window_get_style_media #} (toWindow self))) + +getDevicePixelRatio :: + (MonadIO m, WindowClass self) => self -> m Double +getDevicePixelRatio self + = liftIO + (realToFrac <$> + ({# call webkit_dom_dom_window_get_device_pixel_ratio #} + (toWindow self))) + +getApplicationCache :: + (MonadIO m, WindowClass self) => self -> m (Maybe ApplicationCache) +getApplicationCache self + = liftIO + (maybeNull (makeNewGObject mkApplicationCache) + ({# call webkit_dom_dom_window_get_application_cache #} + (toWindow self))) + +getSessionStorage :: + (MonadIO m, WindowClass self) => self -> m (Maybe Storage) +getSessionStorage self + = liftIO + (maybeNull (makeNewGObject mkStorage) + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_dom_window_get_session_storage #} + (toWindow self) + errorPtr_)) + +getLocalStorage :: + (MonadIO m, WindowClass self) => self -> m (Maybe Storage) +getLocalStorage self + = liftIO + (maybeNull (makeNewGObject mkStorage) + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_dom_window_get_local_storage #} (toWindow self) + errorPtr_)) + +#if WEBKIT_CHECK_VERSION(2,2,2) +getPerformance :: + (MonadIO m, WindowClass self) => self -> m (Maybe Performance) +getPerformance self + = liftIO + (maybeNull (makeNewGObject mkPerformance) + ({# call webkit_dom_dom_window_get_performance #} (toWindow self))) + +getCSS :: (MonadIO m, WindowClass self) => self -> m (Maybe CSS) +getCSS self + = liftIO + (maybeNull (makeNewGObject mkCSS) + ({# call webkit_dom_dom_window_get_css #} (toWindow self))) +#endif + +abort :: (WindowClass self) => EventName self UIEvent +abort = EventName "abort" + +beforeUnload :: (WindowClass self) => EventName self Event +beforeUnload = EventName "beforeunload" + +blurEvent :: (WindowClass self) => EventName self UIEvent +blurEvent = EventName "blur" + +canPlay :: (WindowClass self) => EventName self Event +canPlay = EventName "canplay" + +canPlayThrough :: (WindowClass self) => EventName self Event +canPlayThrough = EventName "canplaythrough" + +change :: (WindowClass self) => EventName self Event +change = EventName "change" + +click :: (WindowClass self) => EventName self MouseEvent +click = EventName "click" + +contextMenu :: (WindowClass self) => EventName self MouseEvent +contextMenu = EventName "contextmenu" + +dblClick :: (WindowClass self) => EventName self MouseEvent +dblClick = EventName "dblclick" + +drag :: (WindowClass self) => EventName self MouseEvent +drag = EventName "drag" + +dragEnd :: (WindowClass self) => EventName self MouseEvent +dragEnd = EventName "dragend" + +dragEnter :: (WindowClass self) => EventName self MouseEvent +dragEnter = EventName "dragenter" + +dragLeave :: (WindowClass self) => EventName self MouseEvent +dragLeave = EventName "dragleave" + +dragOver :: (WindowClass self) => EventName self MouseEvent +dragOver = EventName "dragover" + +dragStart :: (WindowClass self) => EventName self MouseEvent +dragStart = EventName "dragstart" + +drop :: (WindowClass self) => EventName self MouseEvent +drop = EventName "drop" + +durationChange :: (WindowClass self) => EventName self Event +durationChange = EventName "durationchange" + +emptied :: (WindowClass self) => EventName self Event +emptied = EventName "emptied" + +ended :: (WindowClass self) => EventName self Event +ended = EventName "ended" + +error :: (WindowClass self) => EventName self UIEvent +error = EventName "error" + +focusEvent :: (WindowClass self) => EventName self UIEvent +focusEvent = EventName "focus" + +hashChange :: (WindowClass self) => EventName self Event +hashChange = EventName "hashchange" + +input :: (WindowClass self) => EventName self Event +input = EventName "input" + +invalid :: (WindowClass self) => EventName self Event +invalid = EventName "invalid" + +#if WEBKIT_CHECK_VERSION(2,2,2) +keyDown :: (WindowClass self) => EventName self KeyboardEvent +keyDown = EventName "keydown" + +keyPress :: (WindowClass self) => EventName self KeyboardEvent +keyPress = EventName "keypress" + +keyUp :: (WindowClass self) => EventName self KeyboardEvent +keyUp = EventName "keyup" +#endif + +load :: (WindowClass self) => EventName self UIEvent +load = EventName "load" + +loadedData :: (WindowClass self) => EventName self Event +loadedData = EventName "loadeddata" + +loadedMetadata :: (WindowClass self) => EventName self Event +loadedMetadata = EventName "loadedmetadata" + +loadStart :: (WindowClass self) => EventName self Event +loadStart = EventName "loadstart" + +message :: (WindowClass self) => EventName self Event +message = EventName "message" + +mouseDown :: (WindowClass self) => EventName self MouseEvent +mouseDown = EventName "mousedown" + +mouseEnter :: (WindowClass self) => EventName self MouseEvent +mouseEnter = EventName "mouseenter" + +mouseLeave :: (WindowClass self) => EventName self MouseEvent +mouseLeave = EventName "mouseleave" + +mouseMove :: (WindowClass self) => EventName self MouseEvent +mouseMove = EventName "mousemove" + +mouseOut :: (WindowClass self) => EventName self MouseEvent +mouseOut = EventName "mouseout" + +mouseOver :: (WindowClass self) => EventName self MouseEvent +mouseOver = EventName "mouseover" + +mouseUp :: (WindowClass self) => EventName self MouseEvent +mouseUp = EventName "mouseup" + +mouseWheel :: (WindowClass self) => EventName self MouseEvent +mouseWheel = EventName "mousewheel" + +offline :: (WindowClass self) => EventName self Event +offline = EventName "offline" + +online :: (WindowClass self) => EventName self Event +online = EventName "online" + +pageHide :: (WindowClass self) => EventName self Event +pageHide = EventName "pagehide" + +pageShow :: (WindowClass self) => EventName self Event +pageShow = EventName "pageshow" + +pause :: (WindowClass self) => EventName self Event +pause = EventName "pause" + +play :: (WindowClass self) => EventName self Event +play = EventName "play" + +playing :: (WindowClass self) => EventName self Event +playing = EventName "playing" + +popState :: (WindowClass self) => EventName self Event +popState = EventName "popstate" + +progress :: (WindowClass self) => EventName self Event +progress = EventName "progress" + +rateChange :: (WindowClass self) => EventName self Event +rateChange = EventName "ratechange" + +resize :: (WindowClass self) => EventName self UIEvent +resize = EventName "resize" + +scrollEvent :: (WindowClass self) => EventName self UIEvent +scrollEvent = EventName "scroll" + +seeked :: (WindowClass self) => EventName self Event +seeked = EventName "seeked" + +seeking :: (WindowClass self) => EventName self Event +seeking = EventName "seeking" + +select :: (WindowClass self) => EventName self UIEvent +select = EventName "select" + +stalled :: (WindowClass self) => EventName self Event +stalled = EventName "stalled" + +storage :: (WindowClass self) => EventName self Event +storage = EventName "storage" + +submit :: (WindowClass self) => EventName self Event +submit = EventName "submit" + +suspend :: (WindowClass self) => EventName self Event +suspend = EventName "suspend" + +timeUpdate :: (WindowClass self) => EventName self Event +timeUpdate = EventName "timeupdate" + +unload :: (WindowClass self) => EventName self UIEvent +unload = EventName "unload" + +volumeChange :: (WindowClass self) => EventName self Event +volumeChange = EventName "volumechange" + +waiting :: (WindowClass self) => EventName self Event +waiting = EventName "waiting" + +#if WEBKIT_CHECK_VERSION(2,4,0) +wheel :: (WindowClass self) => EventName self WheelEvent +wheel = EventName "wheel" +#endif + +reset :: (WindowClass self) => EventName self Event +reset = EventName "reset" + +search :: (WindowClass self) => EventName self Event +search = EventName "search" + +webKitAnimationEnd :: (WindowClass self) => EventName self Event +webKitAnimationEnd = EventName "webkitanimationend" + +webKitAnimationIteration :: + (WindowClass self) => EventName self Event +webKitAnimationIteration = EventName "webkitanimationiteration" + +webKitAnimationStart :: (WindowClass self) => EventName self Event +webKitAnimationStart = EventName "webkitanimationstart" + +animationEnd :: (WindowClass self) => EventName self Event +animationEnd = EventName "animationend" + +animationIteration :: (WindowClass self) => EventName self Event +animationIteration = EventName "animationiteration" + +animationStart :: (WindowClass self) => EventName self Event +animationStart = EventName "animationstart" + +webKitTransitionEnd :: (WindowClass self) => EventName self Event +webKitTransitionEnd = EventName "webkittransitionend" + +transitionEnd :: (WindowClass self) => EventName self Event +transitionEnd = EventName "transitionend" + +touchStart :: (WindowClass self) => EventName self UIEvent +touchStart = EventName "touchstart" + +touchMove :: (WindowClass self) => EventName self UIEvent +touchMove = EventName "touchmove" + +touchEnd :: (WindowClass self) => EventName self UIEvent +touchEnd = EventName "touchend" + +touchCancel :: (WindowClass self) => EventName self UIEvent +touchCancel = EventName "touchcancel" + +gestureStart :: (WindowClass self) => EventName self UIEvent +gestureStart = EventName "gesturestart" + +gestureChange :: (WindowClass self) => EventName self UIEvent +gestureChange = EventName "gesturechange" + +gestureEnd :: (WindowClass self) => EventName self UIEvent +gestureEnd = EventName "gestureend" + +deviceMotion :: (WindowClass self) => EventName self Event +deviceMotion = EventName "devicemotion" + +deviceOrientation :: (WindowClass self) => EventName self Event +deviceOrientation = EventName "deviceorientation" + +webKitDeviceProximity :: (WindowClass self) => EventName self Event +webKitDeviceProximity = EventName "webkitdeviceproximity" + +webKitWillRevealBottom :: + (WindowClass self) => EventName self Event +webKitWillRevealBottom = EventName "webkitwillrevealbottom" + +webKitWillRevealLeft :: (WindowClass self) => EventName self Event +webKitWillRevealLeft = EventName "webkitwillrevealleft" + +webKitWillRevealRight :: (WindowClass self) => EventName self Event +webKitWillRevealRight = EventName "webkitwillrevealright" + +webKitWillRevealTop :: (WindowClass self) => EventName self Event +webKitWillRevealTop = EventName "webkitwillrevealtop" diff --git a/Graphics/UI/Gtk/WebKit/DOM/XPathExpression.chs b/Graphics/UI/Gtk/WebKit/DOM/XPathExpression.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/XPathExpression.chs @@ -0,0 +1,40 @@ +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 + + +evaluate :: + (MonadIO m, XPathExpressionClass self, NodeClass contextNode, + XPathResultClass inResult) => + self -> + Maybe contextNode -> + Word -> Maybe inResult -> m (Maybe XPathResult) +evaluate self contextNode type' inResult + = liftIO + (maybeNull (makeNewGObject mkXPathResult) + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_xpath_expression_evaluate #} + (toXPathExpression self) + (maybe (Node nullForeignPtr) toNode contextNode) + (fromIntegral type') + (maybe (XPathResult nullForeignPtr) toXPathResult inResult) + errorPtr_)) diff --git a/Graphics/UI/Gtk/WebKit/DOM/XPathNSResolver.chs b/Graphics/UI/Gtk/WebKit/DOM/XPathNSResolver.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/XPathNSResolver.chs @@ -0,0 +1,35 @@ +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 + + +lookupNamespaceURI :: + (MonadIO m, XPathNSResolverClass self, GlibString string) => + self -> string -> m (Maybe string) +lookupNamespaceURI self prefix + = liftIO + ((withUTFString prefix $ + \ prefixPtr -> + {# call webkit_dom_xpath_ns_resolver_lookup_namespace_uri #} + (toXPathNSResolver self) + prefixPtr) + >>= + maybePeek readUTFString) diff --git a/Graphics/UI/Gtk/WebKit/DOM/XPathResult.chs b/Graphics/UI/Gtk/WebKit/DOM/XPathResult.chs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/XPathResult.chs @@ -0,0 +1,147 @@ +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 + + +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_)) + +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 + +getResultType :: + (MonadIO m, XPathResultClass self) => self -> m Word +getResultType self + = liftIO + (fromIntegral <$> + ({# call webkit_dom_xpath_result_get_result_type #} + (toXPathResult self))) + +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_)) + +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) + +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_)) + +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_)) + +getInvalidIteratorState :: + (MonadIO m, XPathResultClass self) => self -> m Bool +getInvalidIteratorState self + = liftIO + (toBool <$> + ({# call webkit_dom_xpath_result_get_invalid_iterator_state #} + (toXPathResult self))) + +getSnapshotLength :: + (MonadIO m, XPathResultClass self) => self -> m Word +getSnapshotLength self + = liftIO + (fromIntegral <$> + (propagateGError $ + \ errorPtr_ -> + {# call webkit_dom_xpath_result_get_snapshot_length #} + (toXPathResult self) + errorPtr_)) diff --git a/Graphics/UI/Gtk/WebKit/DOM/hsevents.c b/Graphics/UI/Gtk/WebKit/DOM/hsevents.c new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/DOM/hsevents.c @@ -0,0 +1,78 @@ +/* WebKitGTK Gtk2Hs WebKitDOMEventTarget implementation + * + * Author : Hamish Mackenzie + * + * Created: 18 August 2012 + * + * Copyright (C) 2012 Hamish Mackenzie + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + */ + +/* GHC's semi-public Rts API */ +#include + +#include "hsgclosure.h" +#include "events.h" +#include + +#if WEBKIT_CHECK_VERSION(2,0,0) + #include +#else + #include + #include +#endif + +#ifdef DEBUG + #define WHEN_DEBUG(a) a +#else + #define WHEN_DEBUG(a) +#endif + +// Once the following bug is fixed we should revist this +// https://bugs.webkit.org/show_bug.cgi?id=77835 + +static void webkit_gtk2hs_closure_callback(GObject *target, WebKitDOMEvent *event, void *user_data) +{ + WHEN_DEBUG(g_debug("webkit_gtk2hs_closure_callback: about to run target=%p, event=%p, user_data=%p", target, event, user_data)); + // I think passing the target to the closure will allow us + // to create call backs that do not hold a reference to + // the target. + GClosure *closure = (GClosure *)user_data; + GValue params[2] = {G_VALUE_INIT, G_VALUE_INIT}; + g_value_init(¶ms[0], WEBKIT_TYPE_DOM_EVENT_TARGET); + g_value_init(¶ms[1], WEBKIT_TYPE_DOM_EVENT); + g_value_set_object(¶ms[0], WEBKIT_DOM_EVENT_TARGET (target)); + g_value_set_object(¶ms[1], event); + g_closure_invoke(closure, NULL, 2, ¶ms[0], NULL); +} + +gboolean webkit_dom_event_target_add_event_listener_closure( + WebKitDOMEventTarget *target, + const char *eventName, + GClosure *closure, + gboolean bubble) +{ + WHEN_DEBUG(g_debug("webkit_dom_event_target_add_event_listener_closure: about to run target %p, eventName=\"%s\", closure=%p", target, eventName, closure)); + return webkit_dom_event_target_add_event_listener( + WEBKIT_DOM_EVENT_TARGET (target), eventName, G_CALLBACK(webkit_gtk2hs_closure_callback), bubble, closure); +} + +gboolean webkit_dom_event_target_remove_event_listener_closure( + WebKitDOMEventTarget *target, + const char *eventName, + GClosure *closure, + gboolean bubble) +{ + WHEN_DEBUG(g_debug("webkit_dom_event_target_remove_event_listener_closure: about to run target %p, eventName=\"%s\", closure=%p (all closures for this target and eventName be removed)", target, eventName, closure)); + return webkit_dom_event_target_remove_event_listener( + WEBKIT_DOM_EVENT_TARGET (target), eventName, G_CALLBACK(webkit_gtk2hs_closure_callback), bubble); +} diff --git a/Graphics/UI/Gtk/WebKit/Download.chs b/Graphics/UI/Gtk/WebKit/Download.chs --- a/Graphics/UI/Gtk/WebKit/Download.chs +++ b/Graphics/UI/Gtk/WebKit/Download.chs @@ -5,7 +5,7 @@ -- Author : Cjacker Huang -- Copyright : (c) 2009 Cjacker Huang -- Copyright : (c) 2010 Andy Stewart --- +-- -- This library is free software; you can redistribute it and/or -- modify it under the terms of the GNU Lesser General Public -- License as published by the Free Software Foundation; either @@ -21,7 +21,7 @@ -- Stability : provisional -- Portability : portable (depends on GHC) -- --- Object used to communicate with the application when downloading +-- Object used to communicate with the application when downloading ----------------------------------------------------------------------------- module Graphics.UI.Gtk.WebKit.Download ( @@ -79,8 +79,8 @@ import System.Glib.FFI import System.Glib.UTFString import System.Glib.GList -import System.Glib.GError -import System.Glib.Attributes +import System.Glib.GError +import System.Glib.Attributes as G import System.Glib.Properties import Graphics.UI.Gtk.Gdk.Events @@ -105,7 +105,7 @@ -- -- Object used to communicate with the application when downloading. downloadNew :: NetworkRequestClass request => request -> IO Download -downloadNew nr = +downloadNew nr = wrapNewGObject mkDownload $ {#call download_new#} (toNetworkRequest nr) -- | Initiates the 'Download'. @@ -127,14 +127,14 @@ -- | Retrieves the URI from 'Download' which is being downloaded. downloadGetUri:: - DownloadClass self => self - -> IO (Maybe String) -- ^ the uri or @Nothing@ in case of failed -downloadGetUri dl = + (DownloadClass self, GlibString string) => self + -> IO (Maybe string) -- ^ the uri or @Nothing@ in case of failed +downloadGetUri dl = {#call download_get_uri#} (toDownload dl) - >>= maybePeek peekCString + >>= maybePeek peekUTFString -- | Retrieves the 'NetworkRequest' that backs the download process. -downloadGetNetworkRequest :: +downloadGetNetworkRequest :: DownloadClass self => self -> IO NetworkRequest downloadGetNetworkRequest dl = @@ -146,39 +146,39 @@ -- * Since 1.1.16 downloadGetNetworkResponse :: DownloadClass self => self - -> IO NetworkResponse -downloadGetNetworkResponse dl = + -> IO NetworkResponse +downloadGetNetworkResponse dl = makeNewGObject mkNetworkResponse $ {#call download_get_network_response#} (toDownload dl) #endif -- | Retrieves the filename that was suggested by the server, -- or the one derived from the URI. -downloadGetSuggestedFilename :: - DownloadClass self => self - -> IO (Maybe String) -- ^ the suggested filename or @Nothing@ in case of failed +downloadGetSuggestedFilename :: + (DownloadClass self, GlibString string) => self + -> IO (Maybe string) -- ^ the suggested filename or @Nothing@ in case of failed downloadGetSuggestedFilename dl = - {#call download_get_suggested_filename#} (toDownload dl) >>= maybePeek peekCString + {#call download_get_suggested_filename#} (toDownload dl) >>= maybePeek peekUTFString -- | Obtains the URI to which the downloaded file will be written. -- --- It is set by Application before call 'downloadStart' -downloadGetDestinationUri :: - DownloadClass self => self - -> IO (Maybe String) +-- It is set by Application before call 'downloadStart' +downloadGetDestinationUri :: + (DownloadClass self, GlibString string) => self + -> IO (Maybe string) downloadGetDestinationUri dl = - {#call download_get_destination_uri#} (toDownload dl) >>= maybePeek peekCString + {#call download_get_destination_uri#} (toDownload dl) >>= maybePeek peekUTFString -- | Defines the URI that should be used to save the downloaded file to. -downloadSetDestinationUri :: - DownloadClass self => self - -> String -- ^ @destination_uri@ - the destination URI +downloadSetDestinationUri :: + (DownloadClass self, GlibString string) => self + -> string -- ^ @destination_uri@ - the destination URI -> IO() downloadSetDestinationUri dl dest = - withCString dest $ \destPtr -> + withUTFString dest $ \destPtr -> {#call download_set_destination_uri#} (toDownload dl) destPtr -- |Determines the current progress of the 'Download' -downloadGetProgress :: +downloadGetProgress :: DownloadClass self => self -> IO Double -- ^ a 'Double' ranging from 0.0 to 1.0 downloadGetProgress dl = @@ -198,27 +198,27 @@ -- |Returns the excepted total size of the download. -- -- This is expected because the server may provide incorrect or missing --- Content-Length. +-- Content-Length. -- -- Notice that this may grow over time. -downloadGetTotalSize :: +downloadGetTotalSize :: DownloadClass self => self -> IO Int -- ^ the expected total size of the downloaded file. downloadGetTotalSize dl = liftM fromIntegral $ {#call download_get_total_size#} (toDownload dl) -- | Returns the current already downleaded size -downloadGetCurrentSize :: +downloadGetCurrentSize :: DownloadClass self => self -> IO Int -- ^ the already downloaded size. downloadGetCurrentSize dl = liftM fromIntegral $ {#call download_get_current_size#} (toDownload dl) -- | Obtains the current status of the 'Download' as 'DownloadStatus' -downloadGetStatus :: +downloadGetStatus :: DownloadClass self => self -> IO DownloadStatus -- ^ the current 'DownloadStatus' -downloadGetStatus dl = +downloadGetStatus dl = liftM (toEnum . fromIntegral) $ {#call download_get_status#} (toDownload dl) -- * Attibutes @@ -226,9 +226,9 @@ -- | The length of the data already downloaded -- -- Default value: 0 --- --- * Since 1.1.2 -- +-- * Since 1.1.2 +-- currentSize :: DownloadClass self => ReadAttr self Int currentSize = readAttr downloadGetCurrentSize @@ -237,14 +237,14 @@ -- Default value: \"\" -- -- * Since 1.1.2 -destinationUri :: DownloadClass self => Attr self (Maybe String) +destinationUri :: (DownloadClass self, GlibString string) => G.Attr self (Maybe string) destinationUri = newAttrFromMaybeStringProperty "destination-uri" -- | The NetworkRequest instance associated with the download. -- -- * Since 1.1.2 -networkRequest :: DownloadClass self => Attr self NetworkRequest -networkRequest = +networkRequest :: DownloadClass self => G.Attr self NetworkRequest +networkRequest = newAttrFromObjectProperty "network-request" {#call pure webkit_network_request_get_type#} @@ -252,15 +252,15 @@ -- | The NetworkResponse instance associated with the download. -- -- * Since 1.1.16 -networkResponse :: DownloadClass self => Attr self NetworkResponse -networkResponse = +networkResponse :: DownloadClass self => G.Attr self NetworkResponse +networkResponse = newAttrFromObjectProperty "network-response" {#call pure webkit_network_response_get_type#} #endif --- | Determines the current progress of the download. --- Notice that, although the progress changes are reported as soon as possible, --- the emission of the notify signal for this property is throttled, for the benefit of download managers. +-- | Determines the current progress of the download. +-- Notice that, although the progress changes are reported as soon as possible, +-- the emission of the notify signal for this property is throttled, for the benefit of download managers. -- If you care about every update, use 'Download' : currentSize. -- -- Allowed values: [0,1] @@ -284,7 +284,7 @@ -- Default value: \"\" -- -- * Since 1.1.2 -suggestedFilename :: DownloadClass self => ReadAttr self (Maybe String) +suggestedFilename :: (DownloadClass self, GlibString string) => ReadAttr self (Maybe string) suggestedFilename = readAttr downloadGetSuggestedFilename -- | The total size of the file @@ -297,14 +297,14 @@ -- * Signals --- | Emitted when download is interrupted either by user action or by network errors, +-- | Emitted when download is interrupted either by user action or by network errors, -- errorDetail will take any value of 'DownloadError'. -- --- 'download': the object on which the signal is emitted --- 'errorCode': the corresponding error code --- 'errorDetail': detailed error code for the error, see 'DownloadError' --- 'reason': a string describing the error --- +-- 'download': the object on which the signal is emitted +-- 'errorCode': the corresponding error code +-- 'errorDetail': detailed error code for the error, see 'DownloadError' +-- 'reason': a string describing the error +-- -- Since 1.1.2 -downloadError :: DownloadClass self => Signal self (Int -> Int -> String -> IO Bool) -downloadError = Signal (connect_INT_INT_STRING__BOOL "error") +downloadError :: (DownloadClass self, GlibString string) => Signal self (Int -> Int -> string -> IO Bool) +downloadError = Signal (connect_INT_INT_GLIBSTRING__BOOL "error") diff --git a/Graphics/UI/Gtk/WebKit/GtkInternals.hs b/Graphics/UI/Gtk/WebKit/GtkInternals.hs new file mode 100644 --- /dev/null +++ b/Graphics/UI/Gtk/WebKit/GtkInternals.hs @@ -0,0 +1,11 @@ +{-# LANGUAGE CPP #-} +module Graphics.UI.Gtk.WebKit.GtkInternals ( + module Graphics.UI.GtkInternals +) where + +import Graphics.UI.GtkInternals (GObjectClass(..), GObject(..), unGObject, toGObject, +#ifdef MIN_VERSION_gtk + ObjectClass(..), Object(..), unObject, toObject, +#endif + objectUnrefFromMainloop, ContainerClass(..), WidgetClass(..), makeNewGObject, Pixbuf, mkPixbuf, + mkTargetList, Adjustment, IMContext, Widget) diff --git a/Graphics/UI/Gtk/WebKit/NetworkRequest.chs b/Graphics/UI/Gtk/WebKit/NetworkRequest.chs --- a/Graphics/UI/Gtk/WebKit/NetworkRequest.chs +++ b/Graphics/UI/Gtk/WebKit/NetworkRequest.chs @@ -47,7 +47,7 @@ import System.Glib.FFI import System.Glib.UTFString import System.Glib.GList -import System.Glib.GError +import System.Glib.GError import Graphics.UI.Gtk.Gdk.Events {#import Graphics.UI.Gtk.Abstract.Object#} (makeNewObject) @@ -60,39 +60,40 @@ -- Constructors - -- | Create a new NetworkRequest with the given @uri@. --- --- It is used whenever WebKit wants to provide information +-- +-- It is used whenever WebKit wants to provide information -- about a request that will be sent, or has been sent. -networkRequestNew :: - String -- ^ @uri@ - the uri of the request +networkRequestNew :: + GlibString string + => string -- ^ @uri@ - the uri of the request -> IO NetworkRequest -networkRequestNew uri = - withCString uri $ \uriPtr -> - wrapNewGObject mkNetworkRequest $ +networkRequestNew uri = + withUTFString uri $ \uriPtr -> + wrapNewGObject mkNetworkRequest $ {#call network_request_new#} uriPtr -- | Set the URI of 'NetworkRequest'. -- -networkRequestSetUri :: - NetworkRequestClass self => self - -> String -- ^ @uri@ - the uri will be set to the request. +networkRequestSetUri :: + GlibString string + => NetworkRequestClass self => self + -> string -- ^ @uri@ - the uri will be set to the request. -> IO() networkRequestSetUri networkrequest uri = - withCString uri $ \uriPtr -> - {#call network_request_set_uri#} + withUTFString uri $ \uriPtr -> + {#call network_request_set_uri#} (toNetworkRequest networkrequest) uriPtr -- | Return the uri of 'NetworkRequest'. -networkRequestGetUri :: - NetworkRequestClass self => self - -> IO (Maybe String) -- ^ the URI or @Nothing@ in case failed. -networkRequestGetUri networkrequest = - {#call network_request_get_uri#} - (toNetworkRequest networkrequest) >>= - maybePeek peekCString - +networkRequestGetUri :: + GlibString string + => NetworkRequestClass self => self + -> IO (Maybe string) -- ^ the URI or @Nothing@ in case failed. +networkRequestGetUri networkrequest = + {#call network_request_get_uri#} + (toNetworkRequest networkrequest) >>= + maybePeek peekUTFString diff --git a/Graphics/UI/Gtk/WebKit/NetworkResponse.chs b/Graphics/UI/Gtk/WebKit/NetworkResponse.chs --- a/Graphics/UI/Gtk/WebKit/NetworkResponse.chs +++ b/Graphics/UI/Gtk/WebKit/NetworkResponse.chs @@ -41,7 +41,7 @@ import System.Glib.FFI import System.Glib.UTFString import System.Glib.GList -import System.Glib.GError +import System.Glib.GError import Graphics.UI.Gtk.Gdk.Events {#import Graphics.UI.Gtk.Abstract.Object#} (makeNewObject) @@ -55,23 +55,23 @@ -- | Set the URI of 'NetworkResponse'. -- -networkResponseSetUri :: - NetworkResponseClass self => self - -> String -- ^ @uri@ - the uri will be set to the response. +networkResponseSetUri :: + (NetworkResponseClass self, GlibString string) => self + -> string -- ^ @uri@ - the uri will be set to the response. -> IO() networkResponseSetUri response uri = - withCString uri $ \uriPtr -> - {#call network_response_set_uri#} + withUTFString uri $ \uriPtr -> + {#call network_response_set_uri#} (toNetworkResponse response) uriPtr -- | Return the uri of 'NetworkResponse'. -networkResponseGetUri :: - NetworkResponseClass self => self - -> IO (Maybe String) -- ^ the URI or @Nothing@ in case failed. -networkResponseGetUri response = - {#call network_response_get_uri#} - (toNetworkResponse response) >>= - maybePeek peekCString +networkResponseGetUri :: + (NetworkResponseClass self, GlibString string) => self + -> IO (Maybe string) -- ^ the URI or @Nothing@ in case failed. +networkResponseGetUri response = + {#call network_response_get_uri#} + (toNetworkResponse response) >>= + maybePeek peekUTFString diff --git a/Graphics/UI/Gtk/WebKit/SecurityOrigin.chs b/Graphics/UI/Gtk/WebKit/SecurityOrigin.chs --- a/Graphics/UI/Gtk/WebKit/SecurityOrigin.chs +++ b/Graphics/UI/Gtk/WebKit/SecurityOrigin.chs @@ -28,9 +28,9 @@ -- | WebKitSecurityOrigin is a representation of a security domain defined by web sites. An origin -- consists of a host name, a protocol, and a port number. Web sites with the same security origin can -- access each other's resources for client-side scripting or database access. --- +-- -- Use 'webFrameGetSecurityOrigin' to get the security origin of a WebKitWebFrame. --- +-- -- Database quotas and usages are also defined per security origin. The cumulative disk usage of an -- origin's databases may be retrieved with 'securityOriginGetWebDatabaseUsage'. An origin's -- quota can be adjusted with 'securityOriginSetWebDatabaseQuota'. @@ -39,7 +39,7 @@ SecurityOrigin, SecurityOriginClass, --- * Methods +-- * Methods securityOriginGetAllWebDatabases, securityOriginGetHost, securityOriginGetPort, @@ -54,7 +54,7 @@ import System.Glib.FFI import System.Glib.UTFString import System.Glib.GList -import System.Glib.GError +import System.Glib.GError import Graphics.UI.Gtk.Gdk.Events {#import Graphics.UI.Gtk.Abstract.Object#} (makeNewObject) @@ -68,7 +68,7 @@ -- | Returns the frame's security origin. securityOriginGetAllWebDatabases :: SecurityOriginClass self => self - -> IO [WebDatabase] + -> IO [WebDatabase] securityOriginGetAllWebDatabases so = do glist <- {#call security_origin_get_all_web_databases#} (toSecurityOrigin so) databasePtr <- fromGList glist @@ -76,10 +76,10 @@ -- | Returns the hostname for the security origin. securityOriginGetHost :: - SecurityOriginClass self => self - -> IO String + (SecurityOriginClass self, GlibString string) => self + -> IO string securityOriginGetHost so = - {#call security_origin_get_host#} (toSecurityOrigin so) >>= peekCString + {#call security_origin_get_host#} (toSecurityOrigin so) >>= peekUTFString -- | Returns the port for the security origin. securityOriginGetPort :: @@ -90,10 +90,10 @@ -- | Returns the protocol for the security origin. securityOriginGetProtocol :: - SecurityOriginClass self => self - -> IO String + (SecurityOriginClass self, GlibString string) => self + -> IO string securityOriginGetProtocol so = - {#call security_origin_get_protocol#} (toSecurityOrigin so) >>= peekCString + {#call security_origin_get_protocol#} (toSecurityOrigin so) >>= peekUTFString -- | Returns the quota for Web Database storage of the security origin in bytes. securityOriginGetWebDatabaseQuota :: @@ -101,14 +101,14 @@ -> IO Int securityOriginGetWebDatabaseQuota so = liftM fromIntegral $ {#call security_origin_get_web_database_quota#} (toSecurityOrigin so) - + -- | Returns the usage for Web Database storage of the security origin in bytes. securityOriginGetWebDatabaseUsage :: SecurityOriginClass self => self -> IO Int securityOriginGetWebDatabaseUsage so = liftM fromIntegral $ {#call security_origin_get_web_database_usage#} (toSecurityOrigin so) - + -- | Adjust the quota for Web Database storage of the security origin securityOriginSetWebDatabaseQuota :: SecurityOriginClass self => self diff --git a/Graphics/UI/Gtk/WebKit/Signals.chs b/Graphics/UI/Gtk/WebKit/Signals.chs --- a/Graphics/UI/Gtk/WebKit/Signals.chs +++ b/Graphics/UI/Gtk/WebKit/Signals.chs @@ -1,4 +1,5 @@ {-# OPTIONS_HADDOCK hide #-} +{-# OPTIONS_GHC -fno-warn-unused-imports #-} -- -*-haskell-*- -- -------------------- automatically generated file - do not edit ------------ -- Callback installers for the GIMP Toolkit (GTK) Binding for Haskell @@ -28,7 +29,7 @@ -- The object system in the second version of GTK is based on GObject from -- GLIB. This base class is rather primitive in that it only implements -- ref and unref methods (and others that are not interesting to us). If --- the marshall list mentions OBJECT it refers to an instance of this +-- the marshall list mentions OBJECT it refers to an instance of this -- GObject which is automatically wrapped with a ref and unref call. -- Structures which are not derived from GObject have to be passed as -- BOXED which gives the signal connect function a possibility to do the @@ -42,36 +43,38 @@ connect_PTR_PTR__NONE, connect_OBJECT__BOOL, - connect_OBJECT_STRING_BOXED__BOOL, + connect_OBJECT_GLIBSTRING_BOXED__BOOL, connect_OBJECT__PTR, - connect_INT_INT_STRING__BOOL, - connect_STRING_STRING_INT_STRING__BOOL, - connect_OBJECT_STRING__BOOL, - connect_OBJECT_STRING_STRING__BOOL, + connect_INT_INT_GLIBSTRING__BOOL, + connect_GLIBSTRING_GLIBSTRING_INT_GLIBSTRING__BOOL, + connect_OBJECT_GLIBSTRING__BOOL, + connect_OBJECT_GLIBSTRING_GLIBSTRING__BOOL, + connect_OBJECT_OBJECT__BOOL, connect_OBJECT_OBJECT_OBJECT_OBJECT__BOOL, - connect_OBJECT_OBJECT_STRING_OBJECT__BOOL, + connect_OBJECT_OBJECT_GLIBSTRING_OBJECT__BOOL, connect_OBJECT_OBJECT_OBJECT_OBJECT__NONE, connect_OBJECT_OBJECT_MOBJECT_MOBJECT__NONE, connect_ENUM_INT__BOOL, connect_NONE__BOOL, connect_NONE__NONE, - connect_MSTRING_MSTRING__NONE, - connect_OBJECT_STRING__NONE, + connect_MGLIBSTRING_MGLIBSTRING__NONE, + connect_OBJECT_GLIBSTRING__NONE, connect_OBJECT_OBJECT__NONE, - connect_STRING_STRING__NONE, + connect_GLIBSTRING_GLIBSTRING__NONE, connect_OBJECT__NONE, connect_INT__NONE, - connect_STRING__NONE, + connect_GLIBSTRING__NONE, ) where -import Control.Monad (liftM) +import Control.Monad (liftM) import System.Glib.FFI -import System.Glib.UTFString (peekUTFString,maybePeekUTFString) +import System.Glib.UTFString (peekUTFString,maybePeekUTFString,newUTFString) +import qualified System.Glib.UTFString as Glib import System.Glib.GError (failOnGError) {#import System.Glib.Signals#} -{#import System.Glib.GObject#} +{#import System.Glib.GObject#} import Graphics.UI.GtkInternals @@ -108,13 +111,13 @@ makeNewGObject (GObject, objectUnrefFromMainloop) (return obj1) >>= \obj1' -> user (unsafeCastGObject obj1') -connect_OBJECT_STRING_BOXED__BOOL :: - (GObjectClass a', GObjectClass obj) => SignalName -> +connect_OBJECT_GLIBSTRING_BOXED__BOOL :: + (GObjectClass a', Glib.GlibString b', GObjectClass obj) => SignalName -> (Ptr c' -> IO c) -> ConnectAfter -> obj -> - (a' -> String -> c -> IO Bool) -> + (a' -> b' -> c -> IO Bool) -> IO (ConnectId obj) -connect_OBJECT_STRING_BOXED__BOOL signal boxedPre3 after obj user = +connect_OBJECT_GLIBSTRING_BOXED__BOOL signal boxedPre3 after obj user = connectGeneric signal after obj action where action :: Ptr GObject -> Ptr GObject -> CString -> Ptr () -> IO Bool action _ obj1 str2 box3 = @@ -138,12 +141,12 @@ makeNewGObject (GObject, objectUnrefFromMainloop) (return obj1) >>= \obj1' -> user (unsafeCastGObject obj1') -connect_INT_INT_STRING__BOOL :: - GObjectClass obj => SignalName -> +connect_INT_INT_GLIBSTRING__BOOL :: + (Glib.GlibString c', GObjectClass obj) => SignalName -> ConnectAfter -> obj -> - (Int -> Int -> String -> IO Bool) -> + (Int -> Int -> c' -> IO Bool) -> IO (ConnectId obj) -connect_INT_INT_STRING__BOOL signal after obj user = +connect_INT_INT_GLIBSTRING__BOOL signal after obj user = connectGeneric signal after obj action where action :: Ptr GObject -> Int -> Int -> CString -> IO Bool action _ int1 int2 str3 = @@ -151,12 +154,12 @@ peekUTFString str3 >>= \str3' -> user int1 int2 str3' -connect_STRING_STRING_INT_STRING__BOOL :: - GObjectClass obj => SignalName -> +connect_GLIBSTRING_GLIBSTRING_INT_GLIBSTRING__BOOL :: + (Glib.GlibString a', Glib.GlibString b', Glib.GlibString d', GObjectClass obj) => SignalName -> ConnectAfter -> obj -> - (String -> String -> Int -> String -> IO Bool) -> + (a' -> b' -> Int -> d' -> IO Bool) -> IO (ConnectId obj) -connect_STRING_STRING_INT_STRING__BOOL signal after obj user = +connect_GLIBSTRING_GLIBSTRING_INT_GLIBSTRING__BOOL signal after obj user = connectGeneric signal after obj action where action :: Ptr GObject -> CString -> CString -> Int -> CString -> IO Bool action _ str1 str2 int3 str4 = @@ -166,12 +169,12 @@ peekUTFString str1 >>= \str1' -> user str1' str2' int3 str4' -connect_OBJECT_STRING__BOOL :: - (GObjectClass a', GObjectClass obj) => SignalName -> +connect_OBJECT_GLIBSTRING__BOOL :: + (GObjectClass a', Glib.GlibString b', GObjectClass obj) => SignalName -> ConnectAfter -> obj -> - (a' -> String -> IO Bool) -> + (a' -> b' -> IO Bool) -> IO (ConnectId obj) -connect_OBJECT_STRING__BOOL signal after obj user = +connect_OBJECT_GLIBSTRING__BOOL signal after obj user = connectGeneric signal after obj action where action :: Ptr GObject -> Ptr GObject -> CString -> IO Bool action _ obj1 str2 = @@ -180,12 +183,12 @@ makeNewGObject (GObject, objectUnrefFromMainloop) (return obj1) >>= \obj1' -> user (unsafeCastGObject obj1') str2' -connect_OBJECT_STRING_STRING__BOOL :: - (GObjectClass a', GObjectClass obj) => SignalName -> +connect_OBJECT_GLIBSTRING_GLIBSTRING__BOOL :: + (GObjectClass a', Glib.GlibString b', Glib.GlibString c', GObjectClass obj) => SignalName -> ConnectAfter -> obj -> - (a' -> String -> String -> IO Bool) -> + (a' -> b' -> c' -> IO Bool) -> IO (ConnectId obj) -connect_OBJECT_STRING_STRING__BOOL signal after obj user = +connect_OBJECT_GLIBSTRING_GLIBSTRING__BOOL signal after obj user = connectGeneric signal after obj action where action :: Ptr GObject -> Ptr GObject -> CString -> CString -> IO Bool action _ obj1 str2 str3 = @@ -195,6 +198,20 @@ makeNewGObject (GObject, objectUnrefFromMainloop) (return obj1) >>= \obj1' -> user (unsafeCastGObject obj1') str2' str3' +connect_OBJECT_OBJECT__BOOL :: + (GObjectClass a', GObjectClass b', GObjectClass obj) => SignalName -> + ConnectAfter -> obj -> + (a' -> b' -> IO Bool) -> + IO (ConnectId obj) +connect_OBJECT_OBJECT__BOOL signal after obj user = + connectGeneric signal after obj action + where action :: Ptr GObject -> Ptr GObject -> Ptr GObject -> IO Bool + action _ obj1 obj2 = + failOnGError $ + makeNewGObject (GObject, objectUnrefFromMainloop) (return obj2) >>= \obj2' -> + makeNewGObject (GObject, objectUnrefFromMainloop) (return obj1) >>= \obj1' -> + user (unsafeCastGObject obj1') (unsafeCastGObject obj2') + connect_OBJECT_OBJECT_OBJECT_OBJECT__BOOL :: (GObjectClass a', GObjectClass b', GObjectClass c', GObjectClass d', GObjectClass obj) => SignalName -> ConnectAfter -> obj -> @@ -211,12 +228,12 @@ makeNewGObject (GObject, objectUnrefFromMainloop) (return obj1) >>= \obj1' -> user (unsafeCastGObject obj1') (unsafeCastGObject obj2') (unsafeCastGObject obj3') (unsafeCastGObject obj4') -connect_OBJECT_OBJECT_STRING_OBJECT__BOOL :: - (GObjectClass a', GObjectClass b', GObjectClass d', GObjectClass obj) => SignalName -> +connect_OBJECT_OBJECT_GLIBSTRING_OBJECT__BOOL :: + (GObjectClass a', GObjectClass b', Glib.GlibString c', GObjectClass d', GObjectClass obj) => SignalName -> ConnectAfter -> obj -> - (a' -> b' -> String -> d' -> IO Bool) -> + (a' -> b' -> c' -> d' -> IO Bool) -> IO (ConnectId obj) -connect_OBJECT_OBJECT_STRING_OBJECT__BOOL signal after obj user = +connect_OBJECT_OBJECT_GLIBSTRING_OBJECT__BOOL signal after obj user = connectGeneric signal after obj action where action :: Ptr GObject -> Ptr GObject -> Ptr GObject -> CString -> Ptr GObject -> IO Bool action _ obj1 obj2 str3 obj4 = @@ -295,12 +312,12 @@ failOnGError $ user -connect_MSTRING_MSTRING__NONE :: - GObjectClass obj => SignalName -> +connect_MGLIBSTRING_MGLIBSTRING__NONE :: + (Glib.GlibString a', Glib.GlibString b', GObjectClass obj) => SignalName -> ConnectAfter -> obj -> - (Maybe String -> Maybe String -> IO ()) -> + (Maybe a' -> Maybe b' -> IO ()) -> IO (ConnectId obj) -connect_MSTRING_MSTRING__NONE signal after obj user = +connect_MGLIBSTRING_MGLIBSTRING__NONE signal after obj user = connectGeneric signal after obj action where action :: Ptr GObject -> CString -> CString -> IO () action _ str1 str2 = @@ -309,12 +326,12 @@ maybePeekUTFString str1 >>= \str1' -> user str1' str2' -connect_OBJECT_STRING__NONE :: - (GObjectClass a', GObjectClass obj) => SignalName -> +connect_OBJECT_GLIBSTRING__NONE :: + (GObjectClass a', Glib.GlibString b', GObjectClass obj) => SignalName -> ConnectAfter -> obj -> - (a' -> String -> IO ()) -> + (a' -> b' -> IO ()) -> IO (ConnectId obj) -connect_OBJECT_STRING__NONE signal after obj user = +connect_OBJECT_GLIBSTRING__NONE signal after obj user = connectGeneric signal after obj action where action :: Ptr GObject -> Ptr GObject -> CString -> IO () action _ obj1 str2 = @@ -337,12 +354,12 @@ makeNewGObject (GObject, objectUnrefFromMainloop) (return obj1) >>= \obj1' -> user (unsafeCastGObject obj1') (unsafeCastGObject obj2') -connect_STRING_STRING__NONE :: - GObjectClass obj => SignalName -> +connect_GLIBSTRING_GLIBSTRING__NONE :: + (Glib.GlibString a', Glib.GlibString b', GObjectClass obj) => SignalName -> ConnectAfter -> obj -> - (String -> String -> IO ()) -> + (a' -> b' -> IO ()) -> IO (ConnectId obj) -connect_STRING_STRING__NONE signal after obj user = +connect_GLIBSTRING_GLIBSTRING__NONE signal after obj user = connectGeneric signal after obj action where action :: Ptr GObject -> CString -> CString -> IO () action _ str1 str2 = @@ -376,12 +393,12 @@ failOnGError $ user int1 -connect_STRING__NONE :: - GObjectClass obj => SignalName -> +connect_GLIBSTRING__NONE :: + (Glib.GlibString a', GObjectClass obj) => SignalName -> ConnectAfter -> obj -> - (String -> IO ()) -> + (a' -> IO ()) -> IO (ConnectId obj) -connect_STRING__NONE signal after obj user = +connect_GLIBSTRING__NONE signal after obj user = connectGeneric signal after obj action where action :: Ptr GObject -> CString -> IO () action _ str1 = diff --git a/Graphics/UI/Gtk/WebKit/Types.chs b/Graphics/UI/Gtk/WebKit/Types.chs --- a/Graphics/UI/Gtk/WebKit/Types.chs +++ b/Graphics/UI/Gtk/WebKit/Types.chs @@ -1,575 +1,4779 @@ -{-# OPTIONS_HADDOCK hide #-} --- -*-haskell-*- --- -------------------- automatically generated file - do not edit ---------- --- Object hierarchy for the GIMP Toolkit (GTK) Binding for Haskell --- --- Author : Axel Simon --- --- Copyright (C) 2001-2005 Axel Simon --- --- This library is free software; you can redistribute it and/or --- modify it under the terms of the GNU Lesser General Public --- License as published by the Free Software Foundation; either --- version 2.1 of the License, or (at your option) any later version. --- --- This library is distributed in the hope that it will be useful, --- but WITHOUT ANY WARRANTY; without even the implied warranty of --- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU --- Lesser General Public License for more details. --- --- #hide - --- | --- Maintainer : gtk2hs-users@lists.sourceforge.net --- Stability : provisional --- Portability : portable (depends on GHC) --- --- This file reflects the Gtk+ object hierarchy in terms of Haskell classes. --- --- Note: the mk... functions were originally meant to simply be an alias --- for the constructor. However, in order to communicate the destructor --- of an object to objectNew, the mk... functions are now a tuple containing --- Haskell constructor and the destructor function pointer. This hack avoids --- changing all modules that simply pass mk... to objectNew. --- -module Graphics.UI.Gtk.WebKit.Types ( - - module Graphics.UI.GtkInternals, - WebView(WebView), WebViewClass, - toWebView, - mkWebView, unWebView, - castToWebView, gTypeWebView, - WebFrame(WebFrame), WebFrameClass, - toWebFrame, - mkWebFrame, unWebFrame, - castToWebFrame, gTypeWebFrame, - WebSettings(WebSettings), WebSettingsClass, - toWebSettings, - mkWebSettings, unWebSettings, - castToWebSettings, gTypeWebSettings, - NetworkRequest(NetworkRequest), NetworkRequestClass, - toNetworkRequest, - mkNetworkRequest, unNetworkRequest, - castToNetworkRequest, gTypeNetworkRequest, - NetworkResponse(NetworkResponse), NetworkResponseClass, - toNetworkResponse, - mkNetworkResponse, unNetworkResponse, - castToNetworkResponse, gTypeNetworkResponse, - Download(Download), DownloadClass, - toDownload, - mkDownload, unDownload, - castToDownload, gTypeDownload, - WebBackForwardList(WebBackForwardList), WebBackForwardListClass, - toWebBackForwardList, - mkWebBackForwardList, unWebBackForwardList, - castToWebBackForwardList, gTypeWebBackForwardList, - WebHistoryItem(WebHistoryItem), WebHistoryItemClass, - toWebHistoryItem, - mkWebHistoryItem, unWebHistoryItem, - castToWebHistoryItem, gTypeWebHistoryItem, - WebInspector(WebInspector), WebInspectorClass, - toWebInspector, - mkWebInspector, unWebInspector, - castToWebInspector, gTypeWebInspector, - HitTestResult(HitTestResult), HitTestResultClass, - toHitTestResult, - mkHitTestResult, unHitTestResult, - castToHitTestResult, gTypeHitTestResult, - SecurityOrigin(SecurityOrigin), SecurityOriginClass, - toSecurityOrigin, - mkSecurityOrigin, unSecurityOrigin, - castToSecurityOrigin, gTypeSecurityOrigin, - SoupAuthDialog(SoupAuthDialog), SoupAuthDialogClass, - toSoupAuthDialog, - mkSoupAuthDialog, unSoupAuthDialog, - castToSoupAuthDialog, gTypeSoupAuthDialog, - WebDatabase(WebDatabase), WebDatabaseClass, - toWebDatabase, - mkWebDatabase, unWebDatabase, - castToWebDatabase, gTypeWebDatabase, - WebDataSource(WebDataSource), WebDataSourceClass, - toWebDataSource, - mkWebDataSource, unWebDataSource, - castToWebDataSource, gTypeWebDataSource, - WebNavigationAction(WebNavigationAction), WebNavigationActionClass, - toWebNavigationAction, - mkWebNavigationAction, unWebNavigationAction, - castToWebNavigationAction, gTypeWebNavigationAction, - WebPolicyDecision(WebPolicyDecision), WebPolicyDecisionClass, - toWebPolicyDecision, - mkWebPolicyDecision, unWebPolicyDecision, - castToWebPolicyDecision, gTypeWebPolicyDecision, - WebResource(WebResource), WebResourceClass, - toWebResource, - mkWebResource, unWebResource, - castToWebResource, gTypeWebResource, - WebWindowFeatures(WebWindowFeatures), WebWindowFeaturesClass, - toWebWindowFeatures, - mkWebWindowFeatures, unWebWindowFeatures, - castToWebWindowFeatures, gTypeWebWindowFeatures, - GeolocationPolicyDecision(GeolocationPolicyDecision), GeolocationPolicyDecisionClass, - toGeolocationPolicyDecision, - mkGeolocationPolicyDecision, unGeolocationPolicyDecision, - castToGeolocationPolicyDecision, gTypeGeolocationPolicyDecision - ) where - -import Foreign.ForeignPtr (ForeignPtr, castForeignPtr, unsafeForeignPtrToPtr) -import Foreign.C.Types (CULong, CUInt) -import System.Glib.GType (GType, typeInstanceIsA) -{#import Graphics.UI.GtkInternals#} - -{# context lib="gtk" prefix="gtk" #} - --- The usage of foreignPtrToPtr should be safe as the evaluation will only be --- forced if the object is used afterwards --- -castTo :: (GObjectClass obj, GObjectClass obj') => GType -> String - -> (obj -> obj') -castTo gtype objTypeName obj = - case toGObject obj of - gobj@(GObject objFPtr) - | typeInstanceIsA ((unsafeForeignPtrToPtr.castForeignPtr) objFPtr) gtype - -> unsafeCastGObject gobj - | otherwise -> error $ "Cannot cast object to " ++ objTypeName - - --- ******************************************************************** WebView - -{#pointer *WebKitWebView as WebView foreign newtype #} deriving (Eq,Ord) - -mkWebView = (WebView, objectUnrefFromMainloop) -unWebView (WebView o) = o - -class ContainerClass o => WebViewClass o -toWebView :: WebViewClass o => o -> WebView -toWebView = unsafeCastGObject . toGObject - -instance WebViewClass WebView -instance ContainerClass WebView -instance WidgetClass WebView -instance ObjectClass WebView -instance GObjectClass WebView where - toGObject = GObject . castForeignPtr . unWebView - unsafeCastGObject = WebView . castForeignPtr . unGObject - -castToWebView :: GObjectClass obj => obj -> WebView -castToWebView = castTo gTypeWebView "WebView" - -gTypeWebView :: GType -gTypeWebView = - {# call fun unsafe webkit_web_view_get_type #} - --- ******************************************************************* WebFrame - -{#pointer *WebKitWebFrame as WebFrame foreign newtype #} deriving (Eq,Ord) - -mkWebFrame = (WebFrame, objectUnrefFromMainloop) -unWebFrame (WebFrame o) = o - -class GObjectClass o => WebFrameClass o -toWebFrame :: WebFrameClass o => o -> WebFrame -toWebFrame = unsafeCastGObject . toGObject - -instance WebFrameClass WebFrame -instance GObjectClass WebFrame where - toGObject = GObject . castForeignPtr . unWebFrame - unsafeCastGObject = WebFrame . castForeignPtr . unGObject - -castToWebFrame :: GObjectClass obj => obj -> WebFrame -castToWebFrame = castTo gTypeWebFrame "WebFrame" - -gTypeWebFrame :: GType -gTypeWebFrame = - {# call fun unsafe webkit_web_frame_get_type #} - --- **************************************************************** WebSettings - -{#pointer *WebKitWebSettings as WebSettings foreign newtype #} deriving (Eq,Ord) - -mkWebSettings = (WebSettings, objectUnrefFromMainloop) -unWebSettings (WebSettings o) = o - -class GObjectClass o => WebSettingsClass o -toWebSettings :: WebSettingsClass o => o -> WebSettings -toWebSettings = unsafeCastGObject . toGObject - -instance WebSettingsClass WebSettings -instance GObjectClass WebSettings where - toGObject = GObject . castForeignPtr . unWebSettings - unsafeCastGObject = WebSettings . castForeignPtr . unGObject - -castToWebSettings :: GObjectClass obj => obj -> WebSettings -castToWebSettings = castTo gTypeWebSettings "WebSettings" - -gTypeWebSettings :: GType -gTypeWebSettings = - {# call fun unsafe webkit_web_settings_get_type #} - --- ************************************************************* NetworkRequest - -{#pointer *WebKitNetworkRequest as NetworkRequest foreign newtype #} deriving (Eq,Ord) - -mkNetworkRequest = (NetworkRequest, objectUnrefFromMainloop) -unNetworkRequest (NetworkRequest o) = o - -class GObjectClass o => NetworkRequestClass o -toNetworkRequest :: NetworkRequestClass o => o -> NetworkRequest -toNetworkRequest = unsafeCastGObject . toGObject - -instance NetworkRequestClass NetworkRequest -instance GObjectClass NetworkRequest where - toGObject = GObject . castForeignPtr . unNetworkRequest - unsafeCastGObject = NetworkRequest . castForeignPtr . unGObject - -castToNetworkRequest :: GObjectClass obj => obj -> NetworkRequest -castToNetworkRequest = castTo gTypeNetworkRequest "NetworkRequest" - -gTypeNetworkRequest :: GType -gTypeNetworkRequest = - {# call fun unsafe webkit_network_request_get_type #} - --- ************************************************************ NetworkResponse - -{#pointer *WebKitNetworkResponse as NetworkResponse foreign newtype #} deriving (Eq,Ord) - -mkNetworkResponse = (NetworkResponse, objectUnrefFromMainloop) -unNetworkResponse (NetworkResponse o) = o - -class GObjectClass o => NetworkResponseClass o -toNetworkResponse :: NetworkResponseClass o => o -> NetworkResponse -toNetworkResponse = unsafeCastGObject . toGObject - -instance NetworkResponseClass NetworkResponse -instance GObjectClass NetworkResponse where - toGObject = GObject . castForeignPtr . unNetworkResponse - unsafeCastGObject = NetworkResponse . castForeignPtr . unGObject - -castToNetworkResponse :: GObjectClass obj => obj -> NetworkResponse -castToNetworkResponse = castTo gTypeNetworkResponse "NetworkResponse" - -gTypeNetworkResponse :: GType -gTypeNetworkResponse = - {# call fun unsafe webkit_network_response_get_type #} - --- ******************************************************************* Download - -{#pointer *WebKitDownload as Download foreign newtype #} deriving (Eq,Ord) - -mkDownload = (Download, objectUnrefFromMainloop) -unDownload (Download o) = o - -class GObjectClass o => DownloadClass o -toDownload :: DownloadClass o => o -> Download -toDownload = unsafeCastGObject . toGObject - -instance DownloadClass Download -instance GObjectClass Download where - toGObject = GObject . castForeignPtr . unDownload - unsafeCastGObject = Download . castForeignPtr . unGObject - -castToDownload :: GObjectClass obj => obj -> Download -castToDownload = castTo gTypeDownload "Download" - -gTypeDownload :: GType -gTypeDownload = - {# call fun unsafe webkit_download_get_type #} - --- ********************************************************* WebBackForwardList - -{#pointer *WebKitWebBackForwardList as WebBackForwardList foreign newtype #} deriving (Eq,Ord) - -mkWebBackForwardList = (WebBackForwardList, objectUnrefFromMainloop) -unWebBackForwardList (WebBackForwardList o) = o - -class GObjectClass o => WebBackForwardListClass o -toWebBackForwardList :: WebBackForwardListClass o => o -> WebBackForwardList -toWebBackForwardList = unsafeCastGObject . toGObject - -instance WebBackForwardListClass WebBackForwardList -instance GObjectClass WebBackForwardList where - toGObject = GObject . castForeignPtr . unWebBackForwardList - unsafeCastGObject = WebBackForwardList . castForeignPtr . unGObject - -castToWebBackForwardList :: GObjectClass obj => obj -> WebBackForwardList -castToWebBackForwardList = castTo gTypeWebBackForwardList "WebBackForwardList" - -gTypeWebBackForwardList :: GType -gTypeWebBackForwardList = - {# call fun unsafe webkit_web_back_forward_list_get_type #} - --- ************************************************************* WebHistoryItem - -{#pointer *WebKitWebHistoryItem as WebHistoryItem foreign newtype #} deriving (Eq,Ord) - -mkWebHistoryItem = (WebHistoryItem, objectUnrefFromMainloop) -unWebHistoryItem (WebHistoryItem o) = o - -class GObjectClass o => WebHistoryItemClass o -toWebHistoryItem :: WebHistoryItemClass o => o -> WebHistoryItem -toWebHistoryItem = unsafeCastGObject . toGObject - -instance WebHistoryItemClass WebHistoryItem -instance GObjectClass WebHistoryItem where - toGObject = GObject . castForeignPtr . unWebHistoryItem - unsafeCastGObject = WebHistoryItem . castForeignPtr . unGObject - -castToWebHistoryItem :: GObjectClass obj => obj -> WebHistoryItem -castToWebHistoryItem = castTo gTypeWebHistoryItem "WebHistoryItem" - -gTypeWebHistoryItem :: GType -gTypeWebHistoryItem = - {# call fun unsafe webkit_web_history_item_get_type #} - --- *************************************************************** WebInspector - -{#pointer *WebKitWebInspector as WebInspector foreign newtype #} deriving (Eq,Ord) - -mkWebInspector = (WebInspector, objectUnrefFromMainloop) -unWebInspector (WebInspector o) = o - -class GObjectClass o => WebInspectorClass o -toWebInspector :: WebInspectorClass o => o -> WebInspector -toWebInspector = unsafeCastGObject . toGObject - -instance WebInspectorClass WebInspector -instance GObjectClass WebInspector where - toGObject = GObject . castForeignPtr . unWebInspector - unsafeCastGObject = WebInspector . castForeignPtr . unGObject - -castToWebInspector :: GObjectClass obj => obj -> WebInspector -castToWebInspector = castTo gTypeWebInspector "WebInspector" - -gTypeWebInspector :: GType -gTypeWebInspector = - {# call fun unsafe webkit_web_inspector_get_type #} - --- ************************************************************** HitTestResult - -{#pointer *WebKitHitTestResult as HitTestResult foreign newtype #} deriving (Eq,Ord) - -mkHitTestResult = (HitTestResult, objectUnrefFromMainloop) -unHitTestResult (HitTestResult o) = o - -class GObjectClass o => HitTestResultClass o -toHitTestResult :: HitTestResultClass o => o -> HitTestResult -toHitTestResult = unsafeCastGObject . toGObject - -instance HitTestResultClass HitTestResult -instance GObjectClass HitTestResult where - toGObject = GObject . castForeignPtr . unHitTestResult - unsafeCastGObject = HitTestResult . castForeignPtr . unGObject - -castToHitTestResult :: GObjectClass obj => obj -> HitTestResult -castToHitTestResult = castTo gTypeHitTestResult "HitTestResult" - -gTypeHitTestResult :: GType -gTypeHitTestResult = - {# call fun unsafe webkit_hit_test_result_get_type #} - --- ************************************************************* SecurityOrigin - -{#pointer *WebKitSecurityOrigin as SecurityOrigin foreign newtype #} deriving (Eq,Ord) - -mkSecurityOrigin = (SecurityOrigin, objectUnrefFromMainloop) -unSecurityOrigin (SecurityOrigin o) = o - -class GObjectClass o => SecurityOriginClass o -toSecurityOrigin :: SecurityOriginClass o => o -> SecurityOrigin -toSecurityOrigin = unsafeCastGObject . toGObject - -instance SecurityOriginClass SecurityOrigin -instance GObjectClass SecurityOrigin where - toGObject = GObject . castForeignPtr . unSecurityOrigin - unsafeCastGObject = SecurityOrigin . castForeignPtr . unGObject - -castToSecurityOrigin :: GObjectClass obj => obj -> SecurityOrigin -castToSecurityOrigin = castTo gTypeSecurityOrigin "SecurityOrigin" - -gTypeSecurityOrigin :: GType -gTypeSecurityOrigin = - {# call fun unsafe webkit_security_origin_get_type #} - --- ************************************************************* SoupAuthDialog - -{#pointer *WebKitSoupAuthDialog as SoupAuthDialog foreign newtype #} deriving (Eq,Ord) - -mkSoupAuthDialog = (SoupAuthDialog, objectUnrefFromMainloop) -unSoupAuthDialog (SoupAuthDialog o) = o - -class GObjectClass o => SoupAuthDialogClass o -toSoupAuthDialog :: SoupAuthDialogClass o => o -> SoupAuthDialog -toSoupAuthDialog = unsafeCastGObject . toGObject - -instance SoupAuthDialogClass SoupAuthDialog -instance GObjectClass SoupAuthDialog where - toGObject = GObject . castForeignPtr . unSoupAuthDialog - unsafeCastGObject = SoupAuthDialog . castForeignPtr . unGObject - -castToSoupAuthDialog :: GObjectClass obj => obj -> SoupAuthDialog -castToSoupAuthDialog = castTo gTypeSoupAuthDialog "SoupAuthDialog" - -gTypeSoupAuthDialog :: GType -gTypeSoupAuthDialog = - {# call fun unsafe webkit_soup_auth_dialog_get_type #} - --- **************************************************************** WebDatabase - -{#pointer *WebKitWebDatabase as WebDatabase foreign newtype #} deriving (Eq,Ord) - -mkWebDatabase = (WebDatabase, objectUnrefFromMainloop) -unWebDatabase (WebDatabase o) = o - -class GObjectClass o => WebDatabaseClass o -toWebDatabase :: WebDatabaseClass o => o -> WebDatabase -toWebDatabase = unsafeCastGObject . toGObject - -instance WebDatabaseClass WebDatabase -instance GObjectClass WebDatabase where - toGObject = GObject . castForeignPtr . unWebDatabase - unsafeCastGObject = WebDatabase . castForeignPtr . unGObject - -castToWebDatabase :: GObjectClass obj => obj -> WebDatabase -castToWebDatabase = castTo gTypeWebDatabase "WebDatabase" - -gTypeWebDatabase :: GType -gTypeWebDatabase = - {# call fun unsafe webkit_web_database_get_type #} - --- ************************************************************** WebDataSource - -{#pointer *WebKitWebDataSource as WebDataSource foreign newtype #} deriving (Eq,Ord) - -mkWebDataSource = (WebDataSource, objectUnrefFromMainloop) -unWebDataSource (WebDataSource o) = o - -class GObjectClass o => WebDataSourceClass o -toWebDataSource :: WebDataSourceClass o => o -> WebDataSource -toWebDataSource = unsafeCastGObject . toGObject - -instance WebDataSourceClass WebDataSource -instance GObjectClass WebDataSource where - toGObject = GObject . castForeignPtr . unWebDataSource - unsafeCastGObject = WebDataSource . castForeignPtr . unGObject - -castToWebDataSource :: GObjectClass obj => obj -> WebDataSource -castToWebDataSource = castTo gTypeWebDataSource "WebDataSource" - -gTypeWebDataSource :: GType -gTypeWebDataSource = - {# call fun unsafe webkit_web_data_source_get_type #} - --- ******************************************************** WebNavigationAction - -{#pointer *WebKitWebNavigationAction as WebNavigationAction foreign newtype #} deriving (Eq,Ord) - -mkWebNavigationAction = (WebNavigationAction, objectUnrefFromMainloop) -unWebNavigationAction (WebNavigationAction o) = o - -class GObjectClass o => WebNavigationActionClass o -toWebNavigationAction :: WebNavigationActionClass o => o -> WebNavigationAction -toWebNavigationAction = unsafeCastGObject . toGObject - -instance WebNavigationActionClass WebNavigationAction -instance GObjectClass WebNavigationAction where - toGObject = GObject . castForeignPtr . unWebNavigationAction - unsafeCastGObject = WebNavigationAction . castForeignPtr . unGObject - -castToWebNavigationAction :: GObjectClass obj => obj -> WebNavigationAction -castToWebNavigationAction = castTo gTypeWebNavigationAction "WebNavigationAction" - -gTypeWebNavigationAction :: GType -gTypeWebNavigationAction = - {# call fun unsafe webkit_web_navigation_action_get_type #} - --- ********************************************************** WebPolicyDecision - -{#pointer *WebKitWebPolicyDecision as WebPolicyDecision foreign newtype #} deriving (Eq,Ord) - -mkWebPolicyDecision = (WebPolicyDecision, objectUnrefFromMainloop) -unWebPolicyDecision (WebPolicyDecision o) = o - -class GObjectClass o => WebPolicyDecisionClass o -toWebPolicyDecision :: WebPolicyDecisionClass o => o -> WebPolicyDecision -toWebPolicyDecision = unsafeCastGObject . toGObject - -instance WebPolicyDecisionClass WebPolicyDecision -instance GObjectClass WebPolicyDecision where - toGObject = GObject . castForeignPtr . unWebPolicyDecision - unsafeCastGObject = WebPolicyDecision . castForeignPtr . unGObject - -castToWebPolicyDecision :: GObjectClass obj => obj -> WebPolicyDecision -castToWebPolicyDecision = castTo gTypeWebPolicyDecision "WebPolicyDecision" - -gTypeWebPolicyDecision :: GType -gTypeWebPolicyDecision = - {# call fun unsafe webkit_web_policy_decision_get_type #} - --- **************************************************************** WebResource - -{#pointer *WebKitWebResource as WebResource foreign newtype #} deriving (Eq,Ord) - -mkWebResource = (WebResource, objectUnrefFromMainloop) -unWebResource (WebResource o) = o - -class GObjectClass o => WebResourceClass o -toWebResource :: WebResourceClass o => o -> WebResource -toWebResource = unsafeCastGObject . toGObject - -instance WebResourceClass WebResource -instance GObjectClass WebResource where - toGObject = GObject . castForeignPtr . unWebResource - unsafeCastGObject = WebResource . castForeignPtr . unGObject - -castToWebResource :: GObjectClass obj => obj -> WebResource -castToWebResource = castTo gTypeWebResource "WebResource" - -gTypeWebResource :: GType -gTypeWebResource = - {# call fun unsafe webkit_web_resource_get_type #} - --- ********************************************************** WebWindowFeatures - -{#pointer *WebKitWebWindowFeatures as WebWindowFeatures foreign newtype #} deriving (Eq,Ord) - -mkWebWindowFeatures = (WebWindowFeatures, objectUnrefFromMainloop) -unWebWindowFeatures (WebWindowFeatures o) = o - -class GObjectClass o => WebWindowFeaturesClass o -toWebWindowFeatures :: WebWindowFeaturesClass o => o -> WebWindowFeatures -toWebWindowFeatures = unsafeCastGObject . toGObject - -instance WebWindowFeaturesClass WebWindowFeatures -instance GObjectClass WebWindowFeatures where - toGObject = GObject . castForeignPtr . unWebWindowFeatures - unsafeCastGObject = WebWindowFeatures . castForeignPtr . unGObject - -castToWebWindowFeatures :: GObjectClass obj => obj -> WebWindowFeatures -castToWebWindowFeatures = castTo gTypeWebWindowFeatures "WebWindowFeatures" - -gTypeWebWindowFeatures :: GType -gTypeWebWindowFeatures = - {# call fun unsafe webkit_web_window_features_get_type #} - --- ************************************************** GeolocationPolicyDecision - -{#pointer *WebKitGeolocationPolicyDecision as GeolocationPolicyDecision foreign newtype #} deriving (Eq,Ord) - -mkGeolocationPolicyDecision = (GeolocationPolicyDecision, objectUnrefFromMainloop) -unGeolocationPolicyDecision (GeolocationPolicyDecision o) = o - -class GObjectClass o => GeolocationPolicyDecisionClass o -toGeolocationPolicyDecision :: GeolocationPolicyDecisionClass o => o -> GeolocationPolicyDecision -toGeolocationPolicyDecision = unsafeCastGObject . toGObject - -instance GeolocationPolicyDecisionClass GeolocationPolicyDecision -instance GObjectClass GeolocationPolicyDecision where - toGObject = GObject . castForeignPtr . unGeolocationPolicyDecision - unsafeCastGObject = GeolocationPolicyDecision . castForeignPtr . unGObject - -castToGeolocationPolicyDecision :: GObjectClass obj => obj -> GeolocationPolicyDecision -castToGeolocationPolicyDecision = castTo gTypeGeolocationPolicyDecision "GeolocationPolicyDecision" - -gTypeGeolocationPolicyDecision :: GType -gTypeGeolocationPolicyDecision = - {# call fun unsafe webkit_geolocation_policy_decision_get_type #} +{-# LANGUAGE CPP #-} +{-# OPTIONS_HADDOCK hide #-} +{-# OPTIONS_GHC -fno-warn-unused-imports #-} +-- -*-haskell-*- +-- -------------------- automatically generated file - do not edit ---------- +-- Object hierarchy for the GIMP Toolkit (GTK) Binding for Haskell +-- +-- Author : Axel Simon +-- +-- Copyright (C) 2001-2005 Axel Simon +-- +-- This library is free software; you can redistribute it and/or +-- modify it under the terms of the GNU Lesser General Public +-- License as published by the Free Software Foundation; either +-- version 2.1 of the License, or (at your option) any later version. +-- +-- This library is distributed in the hope that it will be useful, +-- but WITHOUT ANY WARRANTY; without even the implied warranty of +-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +-- Lesser General Public License for more details. +-- +-- #hide + +-- | +-- Maintainer : gtk2hs-users@lists.sourceforge.net +-- Stability : provisional +-- Portability : portable (depends on GHC) +-- +-- This file reflects the Gtk+ object hierarchy in terms of Haskell classes. +-- +-- Note: the mk... functions were originally meant to simply be an alias +-- for the constructor. However, in order to communicate the destructor +-- of an object to objectNew, the mk... functions are now a tuple containing +-- Haskell constructor and the destructor function pointer. This hack avoids +-- changing all modules that simply pass mk... to objectNew. +-- +module Graphics.UI.Gtk.WebKit.Types ( + + module Graphics.UI.Gtk.WebKit.GtkInternals, + WebView(WebView), WebViewClass, + toWebView, + mkWebView, unWebView, + castToWebView, gTypeWebView, + WebFrame(WebFrame), WebFrameClass, + toWebFrame, + mkWebFrame, unWebFrame, + castToWebFrame, gTypeWebFrame, + WebSettings(WebSettings), WebSettingsClass, + toWebSettings, + mkWebSettings, unWebSettings, + castToWebSettings, gTypeWebSettings, + NetworkRequest(NetworkRequest), NetworkRequestClass, + toNetworkRequest, + mkNetworkRequest, unNetworkRequest, + castToNetworkRequest, gTypeNetworkRequest, + NetworkResponse(NetworkResponse), NetworkResponseClass, + toNetworkResponse, + mkNetworkResponse, unNetworkResponse, + castToNetworkResponse, gTypeNetworkResponse, + Download(Download), DownloadClass, + toDownload, + mkDownload, unDownload, + castToDownload, gTypeDownload, + WebBackForwardList(WebBackForwardList), WebBackForwardListClass, + toWebBackForwardList, + mkWebBackForwardList, unWebBackForwardList, + castToWebBackForwardList, gTypeWebBackForwardList, + WebHistoryItem(WebHistoryItem), WebHistoryItemClass, + toWebHistoryItem, + mkWebHistoryItem, unWebHistoryItem, + castToWebHistoryItem, gTypeWebHistoryItem, + WebInspector(WebInspector), WebInspectorClass, + toWebInspector, + mkWebInspector, unWebInspector, + castToWebInspector, gTypeWebInspector, + HitTestResult(HitTestResult), HitTestResultClass, + toHitTestResult, + mkHitTestResult, unHitTestResult, + castToHitTestResult, gTypeHitTestResult, + SecurityOrigin(SecurityOrigin), SecurityOriginClass, + toSecurityOrigin, + mkSecurityOrigin, unSecurityOrigin, + castToSecurityOrigin, gTypeSecurityOrigin, + SoupAuthDialog(SoupAuthDialog), SoupAuthDialogClass, + toSoupAuthDialog, + mkSoupAuthDialog, unSoupAuthDialog, + castToSoupAuthDialog, gTypeSoupAuthDialog, + WebDatabase(WebDatabase), WebDatabaseClass, + toWebDatabase, + mkWebDatabase, unWebDatabase, + castToWebDatabase, gTypeWebDatabase, + WebDataSource(WebDataSource), WebDataSourceClass, + toWebDataSource, + mkWebDataSource, unWebDataSource, + castToWebDataSource, gTypeWebDataSource, + WebNavigationAction(WebNavigationAction), WebNavigationActionClass, + toWebNavigationAction, + mkWebNavigationAction, unWebNavigationAction, + castToWebNavigationAction, gTypeWebNavigationAction, + WebPolicyDecision(WebPolicyDecision), WebPolicyDecisionClass, + toWebPolicyDecision, + mkWebPolicyDecision, unWebPolicyDecision, + castToWebPolicyDecision, gTypeWebPolicyDecision, + WebResource(WebResource), WebResourceClass, + toWebResource, + mkWebResource, unWebResource, + castToWebResource, gTypeWebResource, + WebWindowFeatures(WebWindowFeatures), WebWindowFeaturesClass, + toWebWindowFeatures, + mkWebWindowFeatures, unWebWindowFeatures, + castToWebWindowFeatures, gTypeWebWindowFeatures, + GeolocationPolicyDecision(GeolocationPolicyDecision), GeolocationPolicyDecisionClass, + toGeolocationPolicyDecision, + mkGeolocationPolicyDecision, unGeolocationPolicyDecision, + castToGeolocationPolicyDecision, gTypeGeolocationPolicyDecision, + AudioTrack(AudioTrack), AudioTrackClass, + toAudioTrack, + mkAudioTrack, unAudioTrack, + castToAudioTrack, gTypeAudioTrack, + BarProp(BarProp), BarPropClass, + toBarProp, + mkBarProp, unBarProp, + castToBarProp, gTypeBarProp, + Blob(Blob), BlobClass, + toBlob, + mkBlob, unBlob, + castToBlob, gTypeBlob, + File(File), FileClass, + toFile, + mkFile, unFile, + castToFile, gTypeFile, + CSS(CSS), CSSClass, + toCSS, + mkCSS, unCSS, + castToCSS, gTypeCSS, + CSSRule(CSSRule), CSSRuleClass, + toCSSRule, + mkCSSRule, unCSSRule, + castToCSSRule, gTypeCSSRule, + CSSRuleList(CSSRuleList), CSSRuleListClass, + toCSSRuleList, + mkCSSRuleList, unCSSRuleList, + castToCSSRuleList, gTypeCSSRuleList, + CSSStyleDeclaration(CSSStyleDeclaration), CSSStyleDeclarationClass, + toCSSStyleDeclaration, + mkCSSStyleDeclaration, unCSSStyleDeclaration, + castToCSSStyleDeclaration, gTypeCSSStyleDeclaration, + CSSValue(CSSValue), CSSValueClass, + toCSSValue, + mkCSSValue, unCSSValue, + castToCSSValue, gTypeCSSValue, + DOMImplementation(DOMImplementation), DOMImplementationClass, + toDOMImplementation, + mkDOMImplementation, unDOMImplementation, + castToDOMImplementation, gTypeDOMImplementation, + DOMNamedFlowCollection(DOMNamedFlowCollection), DOMNamedFlowCollectionClass, + toDOMNamedFlowCollection, + mkDOMNamedFlowCollection, unDOMNamedFlowCollection, + castToDOMNamedFlowCollection, gTypeDOMNamedFlowCollection, + DOMStringList(DOMStringList), DOMStringListClass, + toDOMStringList, + mkDOMStringList, unDOMStringList, + castToDOMStringList, gTypeDOMStringList, + DOMTokenList(DOMTokenList), DOMTokenListClass, + toDOMTokenList, + mkDOMTokenList, unDOMTokenList, + castToDOMTokenList, gTypeDOMTokenList, + DOMSettableTokenList(DOMSettableTokenList), DOMSettableTokenListClass, + toDOMSettableTokenList, + mkDOMSettableTokenList, unDOMSettableTokenList, + castToDOMSettableTokenList, gTypeDOMSettableTokenList, + Event(Event), EventClass, + toEvent, + mkEvent, unEvent, + castToEvent, gTypeEvent, + UIEvent(UIEvent), UIEventClass, + toUIEvent, + mkUIEvent, unUIEvent, + castToUIEvent, gTypeUIEvent, + KeyboardEvent(KeyboardEvent), KeyboardEventClass, + toKeyboardEvent, + mkKeyboardEvent, unKeyboardEvent, + castToKeyboardEvent, gTypeKeyboardEvent, + MouseEvent(MouseEvent), MouseEventClass, + toMouseEvent, + mkMouseEvent, unMouseEvent, + castToMouseEvent, gTypeMouseEvent, + WheelEvent(WheelEvent), WheelEventClass, + toWheelEvent, + mkWheelEvent, unWheelEvent, + castToWheelEvent, gTypeWheelEvent, + EventTarget(EventTarget), EventTargetClass, + toEventTarget, + mkEventTarget, unEventTarget, + castToEventTarget, gTypeEventTarget, + ApplicationCache(ApplicationCache), ApplicationCacheClass, + toApplicationCache, + mkApplicationCache, unApplicationCache, + castToApplicationCache, gTypeApplicationCache, + AudioTrackList(AudioTrackList), AudioTrackListClass, + toAudioTrackList, + mkAudioTrackList, unAudioTrackList, + castToAudioTrackList, gTypeAudioTrackList, + BatteryManager(BatteryManager), BatteryManagerClass, + toBatteryManager, + mkBatteryManager, unBatteryManager, + castToBatteryManager, gTypeBatteryManager, + MessagePort(MessagePort), MessagePortClass, + toMessagePort, + mkMessagePort, unMessagePort, + castToMessagePort, gTypeMessagePort, + Node(Node), NodeClass, + toNode, + mkNode, unNode, + castToNode, gTypeNode, + Attr(Attr), AttrClass, + toAttr, + mkAttr, unAttr, + castToAttr, gTypeAttr, + CharacterData(CharacterData), CharacterDataClass, + toCharacterData, + mkCharacterData, unCharacterData, + castToCharacterData, gTypeCharacterData, + Comment(Comment), CommentClass, + toComment, + mkComment, unComment, + castToComment, gTypeComment, + ProcessingInstruction(ProcessingInstruction), ProcessingInstructionClass, + toProcessingInstruction, + mkProcessingInstruction, unProcessingInstruction, + castToProcessingInstruction, gTypeProcessingInstruction, + Text(Text), TextClass, + toText, + mkText, unText, + castToText, gTypeText, + CDATASection(CDATASection), CDATASectionClass, + toCDATASection, + mkCDATASection, unCDATASection, + castToCDATASection, gTypeCDATASection, + Document(Document), DocumentClass, + toDocument, + mkDocument, unDocument, + castToDocument, gTypeDocument, + HTMLDocument(HTMLDocument), HTMLDocumentClass, + toHTMLDocument, + mkHTMLDocument, unHTMLDocument, + castToHTMLDocument, gTypeHTMLDocument, + DocumentFragment(DocumentFragment), DocumentFragmentClass, + toDocumentFragment, + mkDocumentFragment, unDocumentFragment, + castToDocumentFragment, gTypeDocumentFragment, + DocumentType(DocumentType), DocumentTypeClass, + toDocumentType, + mkDocumentType, unDocumentType, + castToDocumentType, gTypeDocumentType, + Element(Element), ElementClass, + toElement, + mkElement, unElement, + castToElement, gTypeElement, + HTMLElement(HTMLElement), HTMLElementClass, + toHTMLElement, + mkHTMLElement, unHTMLElement, + castToHTMLElement, gTypeHTMLElement, + HTMLAnchorElement(HTMLAnchorElement), HTMLAnchorElementClass, + toHTMLAnchorElement, + mkHTMLAnchorElement, unHTMLAnchorElement, + castToHTMLAnchorElement, gTypeHTMLAnchorElement, + HTMLAppletElement(HTMLAppletElement), HTMLAppletElementClass, + toHTMLAppletElement, + mkHTMLAppletElement, unHTMLAppletElement, + castToHTMLAppletElement, gTypeHTMLAppletElement, + HTMLAreaElement(HTMLAreaElement), HTMLAreaElementClass, + toHTMLAreaElement, + mkHTMLAreaElement, unHTMLAreaElement, + castToHTMLAreaElement, gTypeHTMLAreaElement, + HTMLBRElement(HTMLBRElement), HTMLBRElementClass, + toHTMLBRElement, + mkHTMLBRElement, unHTMLBRElement, + castToHTMLBRElement, gTypeHTMLBRElement, + HTMLBaseElement(HTMLBaseElement), HTMLBaseElementClass, + toHTMLBaseElement, + mkHTMLBaseElement, unHTMLBaseElement, + castToHTMLBaseElement, gTypeHTMLBaseElement, + HTMLBaseFontElement(HTMLBaseFontElement), HTMLBaseFontElementClass, + toHTMLBaseFontElement, + mkHTMLBaseFontElement, unHTMLBaseFontElement, + castToHTMLBaseFontElement, gTypeHTMLBaseFontElement, + HTMLBodyElement(HTMLBodyElement), HTMLBodyElementClass, + toHTMLBodyElement, + mkHTMLBodyElement, unHTMLBodyElement, + castToHTMLBodyElement, gTypeHTMLBodyElement, + HTMLButtonElement(HTMLButtonElement), HTMLButtonElementClass, + toHTMLButtonElement, + mkHTMLButtonElement, unHTMLButtonElement, + castToHTMLButtonElement, gTypeHTMLButtonElement, + HTMLCanvasElement(HTMLCanvasElement), HTMLCanvasElementClass, + toHTMLCanvasElement, + mkHTMLCanvasElement, unHTMLCanvasElement, + castToHTMLCanvasElement, gTypeHTMLCanvasElement, + HTMLDListElement(HTMLDListElement), HTMLDListElementClass, + toHTMLDListElement, + mkHTMLDListElement, unHTMLDListElement, + castToHTMLDListElement, gTypeHTMLDListElement, + HTMLDetailsElement(HTMLDetailsElement), HTMLDetailsElementClass, + toHTMLDetailsElement, + mkHTMLDetailsElement, unHTMLDetailsElement, + castToHTMLDetailsElement, gTypeHTMLDetailsElement, + HTMLDirectoryElement(HTMLDirectoryElement), HTMLDirectoryElementClass, + toHTMLDirectoryElement, + mkHTMLDirectoryElement, unHTMLDirectoryElement, + castToHTMLDirectoryElement, gTypeHTMLDirectoryElement, + HTMLDivElement(HTMLDivElement), HTMLDivElementClass, + toHTMLDivElement, + mkHTMLDivElement, unHTMLDivElement, + castToHTMLDivElement, gTypeHTMLDivElement, + HTMLEmbedElement(HTMLEmbedElement), HTMLEmbedElementClass, + toHTMLEmbedElement, + mkHTMLEmbedElement, unHTMLEmbedElement, + castToHTMLEmbedElement, gTypeHTMLEmbedElement, + HTMLFieldSetElement(HTMLFieldSetElement), HTMLFieldSetElementClass, + toHTMLFieldSetElement, + mkHTMLFieldSetElement, unHTMLFieldSetElement, + castToHTMLFieldSetElement, gTypeHTMLFieldSetElement, + HTMLFontElement(HTMLFontElement), HTMLFontElementClass, + toHTMLFontElement, + mkHTMLFontElement, unHTMLFontElement, + castToHTMLFontElement, gTypeHTMLFontElement, + HTMLFormElement(HTMLFormElement), HTMLFormElementClass, + toHTMLFormElement, + mkHTMLFormElement, unHTMLFormElement, + castToHTMLFormElement, gTypeHTMLFormElement, + HTMLFrameElement(HTMLFrameElement), HTMLFrameElementClass, + toHTMLFrameElement, + mkHTMLFrameElement, unHTMLFrameElement, + castToHTMLFrameElement, gTypeHTMLFrameElement, + HTMLFrameSetElement(HTMLFrameSetElement), HTMLFrameSetElementClass, + toHTMLFrameSetElement, + mkHTMLFrameSetElement, unHTMLFrameSetElement, + castToHTMLFrameSetElement, gTypeHTMLFrameSetElement, + HTMLHRElement(HTMLHRElement), HTMLHRElementClass, + toHTMLHRElement, + mkHTMLHRElement, unHTMLHRElement, + castToHTMLHRElement, gTypeHTMLHRElement, + HTMLHeadElement(HTMLHeadElement), HTMLHeadElementClass, + toHTMLHeadElement, + mkHTMLHeadElement, unHTMLHeadElement, + castToHTMLHeadElement, gTypeHTMLHeadElement, + HTMLHeadingElement(HTMLHeadingElement), HTMLHeadingElementClass, + toHTMLHeadingElement, + mkHTMLHeadingElement, unHTMLHeadingElement, + castToHTMLHeadingElement, gTypeHTMLHeadingElement, + HTMLHtmlElement(HTMLHtmlElement), HTMLHtmlElementClass, + toHTMLHtmlElement, + mkHTMLHtmlElement, unHTMLHtmlElement, + castToHTMLHtmlElement, gTypeHTMLHtmlElement, + HTMLIFrameElement(HTMLIFrameElement), HTMLIFrameElementClass, + toHTMLIFrameElement, + mkHTMLIFrameElement, unHTMLIFrameElement, + castToHTMLIFrameElement, gTypeHTMLIFrameElement, + HTMLImageElement(HTMLImageElement), HTMLImageElementClass, + toHTMLImageElement, + mkHTMLImageElement, unHTMLImageElement, + castToHTMLImageElement, gTypeHTMLImageElement, + HTMLInputElement(HTMLInputElement), HTMLInputElementClass, + toHTMLInputElement, + mkHTMLInputElement, unHTMLInputElement, + castToHTMLInputElement, gTypeHTMLInputElement, + HTMLKeygenElement(HTMLKeygenElement), HTMLKeygenElementClass, + toHTMLKeygenElement, + mkHTMLKeygenElement, unHTMLKeygenElement, + castToHTMLKeygenElement, gTypeHTMLKeygenElement, + HTMLLIElement(HTMLLIElement), HTMLLIElementClass, + toHTMLLIElement, + mkHTMLLIElement, unHTMLLIElement, + castToHTMLLIElement, gTypeHTMLLIElement, + HTMLLabelElement(HTMLLabelElement), HTMLLabelElementClass, + toHTMLLabelElement, + mkHTMLLabelElement, unHTMLLabelElement, + castToHTMLLabelElement, gTypeHTMLLabelElement, + HTMLLegendElement(HTMLLegendElement), HTMLLegendElementClass, + toHTMLLegendElement, + mkHTMLLegendElement, unHTMLLegendElement, + castToHTMLLegendElement, gTypeHTMLLegendElement, + HTMLLinkElement(HTMLLinkElement), HTMLLinkElementClass, + toHTMLLinkElement, + mkHTMLLinkElement, unHTMLLinkElement, + castToHTMLLinkElement, gTypeHTMLLinkElement, + HTMLMapElement(HTMLMapElement), HTMLMapElementClass, + toHTMLMapElement, + mkHTMLMapElement, unHTMLMapElement, + castToHTMLMapElement, gTypeHTMLMapElement, + HTMLMarqueeElement(HTMLMarqueeElement), HTMLMarqueeElementClass, + toHTMLMarqueeElement, + mkHTMLMarqueeElement, unHTMLMarqueeElement, + castToHTMLMarqueeElement, gTypeHTMLMarqueeElement, + HTMLMenuElement(HTMLMenuElement), HTMLMenuElementClass, + toHTMLMenuElement, + mkHTMLMenuElement, unHTMLMenuElement, + castToHTMLMenuElement, gTypeHTMLMenuElement, + HTMLMetaElement(HTMLMetaElement), HTMLMetaElementClass, + toHTMLMetaElement, + mkHTMLMetaElement, unHTMLMetaElement, + castToHTMLMetaElement, gTypeHTMLMetaElement, + HTMLModElement(HTMLModElement), HTMLModElementClass, + toHTMLModElement, + mkHTMLModElement, unHTMLModElement, + castToHTMLModElement, gTypeHTMLModElement, + HTMLOListElement(HTMLOListElement), HTMLOListElementClass, + toHTMLOListElement, + mkHTMLOListElement, unHTMLOListElement, + castToHTMLOListElement, gTypeHTMLOListElement, + HTMLObjectElement(HTMLObjectElement), HTMLObjectElementClass, + toHTMLObjectElement, + mkHTMLObjectElement, unHTMLObjectElement, + castToHTMLObjectElement, gTypeHTMLObjectElement, + HTMLOptGroupElement(HTMLOptGroupElement), HTMLOptGroupElementClass, + toHTMLOptGroupElement, + mkHTMLOptGroupElement, unHTMLOptGroupElement, + castToHTMLOptGroupElement, gTypeHTMLOptGroupElement, + HTMLOptionElement(HTMLOptionElement), HTMLOptionElementClass, + toHTMLOptionElement, + mkHTMLOptionElement, unHTMLOptionElement, + castToHTMLOptionElement, gTypeHTMLOptionElement, + HTMLParagraphElement(HTMLParagraphElement), HTMLParagraphElementClass, + toHTMLParagraphElement, + mkHTMLParagraphElement, unHTMLParagraphElement, + castToHTMLParagraphElement, gTypeHTMLParagraphElement, + HTMLParamElement(HTMLParamElement), HTMLParamElementClass, + toHTMLParamElement, + mkHTMLParamElement, unHTMLParamElement, + castToHTMLParamElement, gTypeHTMLParamElement, + HTMLPreElement(HTMLPreElement), HTMLPreElementClass, + toHTMLPreElement, + mkHTMLPreElement, unHTMLPreElement, + castToHTMLPreElement, gTypeHTMLPreElement, + HTMLQuoteElement(HTMLQuoteElement), HTMLQuoteElementClass, + toHTMLQuoteElement, + mkHTMLQuoteElement, unHTMLQuoteElement, + castToHTMLQuoteElement, gTypeHTMLQuoteElement, + HTMLScriptElement(HTMLScriptElement), HTMLScriptElementClass, + toHTMLScriptElement, + mkHTMLScriptElement, unHTMLScriptElement, + castToHTMLScriptElement, gTypeHTMLScriptElement, + HTMLSelectElement(HTMLSelectElement), HTMLSelectElementClass, + toHTMLSelectElement, + mkHTMLSelectElement, unHTMLSelectElement, + castToHTMLSelectElement, gTypeHTMLSelectElement, + HTMLStyleElement(HTMLStyleElement), HTMLStyleElementClass, + toHTMLStyleElement, + mkHTMLStyleElement, unHTMLStyleElement, + castToHTMLStyleElement, gTypeHTMLStyleElement, + HTMLTableCaptionElement(HTMLTableCaptionElement), HTMLTableCaptionElementClass, + toHTMLTableCaptionElement, + mkHTMLTableCaptionElement, unHTMLTableCaptionElement, + castToHTMLTableCaptionElement, gTypeHTMLTableCaptionElement, + HTMLTableCellElement(HTMLTableCellElement), HTMLTableCellElementClass, + toHTMLTableCellElement, + mkHTMLTableCellElement, unHTMLTableCellElement, + castToHTMLTableCellElement, gTypeHTMLTableCellElement, + HTMLTableColElement(HTMLTableColElement), HTMLTableColElementClass, + toHTMLTableColElement, + mkHTMLTableColElement, unHTMLTableColElement, + castToHTMLTableColElement, gTypeHTMLTableColElement, + HTMLTableElement(HTMLTableElement), HTMLTableElementClass, + toHTMLTableElement, + mkHTMLTableElement, unHTMLTableElement, + castToHTMLTableElement, gTypeHTMLTableElement, + HTMLTableRowElement(HTMLTableRowElement), HTMLTableRowElementClass, + toHTMLTableRowElement, + mkHTMLTableRowElement, unHTMLTableRowElement, + castToHTMLTableRowElement, gTypeHTMLTableRowElement, + HTMLTableSectionElement(HTMLTableSectionElement), HTMLTableSectionElementClass, + toHTMLTableSectionElement, + mkHTMLTableSectionElement, unHTMLTableSectionElement, + castToHTMLTableSectionElement, gTypeHTMLTableSectionElement, + HTMLTextAreaElement(HTMLTextAreaElement), HTMLTextAreaElementClass, + toHTMLTextAreaElement, + mkHTMLTextAreaElement, unHTMLTextAreaElement, + castToHTMLTextAreaElement, gTypeHTMLTextAreaElement, + HTMLTitleElement(HTMLTitleElement), HTMLTitleElementClass, + toHTMLTitleElement, + mkHTMLTitleElement, unHTMLTitleElement, + castToHTMLTitleElement, gTypeHTMLTitleElement, + HTMLUListElement(HTMLUListElement), HTMLUListElementClass, + toHTMLUListElement, + mkHTMLUListElement, unHTMLUListElement, + castToHTMLUListElement, gTypeHTMLUListElement, + EntityReference(EntityReference), EntityReferenceClass, + toEntityReference, + mkEntityReference, unEntityReference, + castToEntityReference, gTypeEntityReference, + Performance(Performance), PerformanceClass, + toPerformance, + mkPerformance, unPerformance, + castToPerformance, gTypePerformance, + TextTrack(TextTrack), TextTrackClass, + toTextTrack, + mkTextTrack, unTextTrack, + castToTextTrack, gTypeTextTrack, + TextTrackCue(TextTrackCue), TextTrackCueClass, + toTextTrackCue, + mkTextTrackCue, unTextTrackCue, + castToTextTrackCue, gTypeTextTrackCue, + TextTrackList(TextTrackList), TextTrackListClass, + toTextTrackList, + mkTextTrackList, unTextTrackList, + castToTextTrackList, gTypeTextTrackList, + VideoTrackList(VideoTrackList), VideoTrackListClass, + toVideoTrackList, + mkVideoTrackList, unVideoTrackList, + castToVideoTrackList, gTypeVideoTrackList, + WebKitNamedFlow(WebKitNamedFlow), WebKitNamedFlowClass, + toWebKitNamedFlow, + mkWebKitNamedFlow, unWebKitNamedFlow, + castToWebKitNamedFlow, gTypeWebKitNamedFlow, + Window(Window), WindowClass, + toWindow, + mkWindow, unWindow, + castToWindow, gTypeWindow, + FileList(FileList), FileListClass, + toFileList, + mkFileList, unFileList, + castToFileList, gTypeFileList, + Geolocation(Geolocation), GeolocationClass, + toGeolocation, + mkGeolocation, unGeolocation, + castToGeolocation, gTypeGeolocation, + HTMLCollection(HTMLCollection), HTMLCollectionClass, + toHTMLCollection, + mkHTMLCollection, unHTMLCollection, + castToHTMLCollection, gTypeHTMLCollection, + HTMLOptionsCollection(HTMLOptionsCollection), HTMLOptionsCollectionClass, + toHTMLOptionsCollection, + mkHTMLOptionsCollection, unHTMLOptionsCollection, + castToHTMLOptionsCollection, gTypeHTMLOptionsCollection, + HTMLMediaElement(HTMLMediaElement), HTMLMediaElementClass, + toHTMLMediaElement, + mkHTMLMediaElement, unHTMLMediaElement, + castToHTMLMediaElement, gTypeHTMLMediaElement, + HTMLAudioElement(HTMLAudioElement), HTMLAudioElementClass, + toHTMLAudioElement, + mkHTMLAudioElement, unHTMLAudioElement, + castToHTMLAudioElement, gTypeHTMLAudioElement, + HTMLVideoElement(HTMLVideoElement), HTMLVideoElementClass, + toHTMLVideoElement, + mkHTMLVideoElement, unHTMLVideoElement, + castToHTMLVideoElement, gTypeHTMLVideoElement, + History(History), HistoryClass, + toHistory, + mkHistory, unHistory, + castToHistory, gTypeHistory, + Location(Location), LocationClass, + toLocation, + mkLocation, unLocation, + castToLocation, gTypeLocation, + MediaError(MediaError), MediaErrorClass, + toMediaError, + mkMediaError, unMediaError, + castToMediaError, gTypeMediaError, + MediaList(MediaList), MediaListClass, + toMediaList, + mkMediaList, unMediaList, + castToMediaList, gTypeMediaList, + MediaQueryList(MediaQueryList), MediaQueryListClass, + toMediaQueryList, + mkMediaQueryList, unMediaQueryList, + castToMediaQueryList, gTypeMediaQueryList, + MimeType(MimeType), MimeTypeClass, + toMimeType, + mkMimeType, unMimeType, + castToMimeType, gTypeMimeType, + MimeTypeArray(MimeTypeArray), MimeTypeArrayClass, + toMimeTypeArray, + mkMimeTypeArray, unMimeTypeArray, + castToMimeTypeArray, gTypeMimeTypeArray, + NamedNodeMap(NamedNodeMap), NamedNodeMapClass, + toNamedNodeMap, + mkNamedNodeMap, unNamedNodeMap, + castToNamedNodeMap, gTypeNamedNodeMap, + Navigator(Navigator), NavigatorClass, + toNavigator, + mkNavigator, unNavigator, + castToNavigator, gTypeNavigator, + NodeFilter(NodeFilter), NodeFilterClass, + toNodeFilter, + mkNodeFilter, unNodeFilter, + castToNodeFilter, gTypeNodeFilter, + NodeIterator(NodeIterator), NodeIteratorClass, + toNodeIterator, + mkNodeIterator, unNodeIterator, + castToNodeIterator, gTypeNodeIterator, + NodeList(NodeList), NodeListClass, + toNodeList, + mkNodeList, unNodeList, + castToNodeList, gTypeNodeList, + PerformanceNavigation(PerformanceNavigation), PerformanceNavigationClass, + toPerformanceNavigation, + mkPerformanceNavigation, unPerformanceNavigation, + castToPerformanceNavigation, gTypePerformanceNavigation, + PerformanceTiming(PerformanceTiming), PerformanceTimingClass, + toPerformanceTiming, + mkPerformanceTiming, unPerformanceTiming, + castToPerformanceTiming, gTypePerformanceTiming, + Plugin(Plugin), PluginClass, + toPlugin, + mkPlugin, unPlugin, + castToPlugin, gTypePlugin, + PluginArray(PluginArray), PluginArrayClass, + toPluginArray, + mkPluginArray, unPluginArray, + castToPluginArray, gTypePluginArray, + Range(Range), RangeClass, + toRange, + mkRange, unRange, + castToRange, gTypeRange, + Screen(Screen), ScreenClass, + toScreen, + mkScreen, unScreen, + castToScreen, gTypeScreen, + SecurityPolicy(SecurityPolicy), SecurityPolicyClass, + toSecurityPolicy, + mkSecurityPolicy, unSecurityPolicy, + castToSecurityPolicy, gTypeSecurityPolicy, + Selection(Selection), SelectionClass, + toSelection, + mkSelection, unSelection, + castToSelection, gTypeSelection, + Storage(Storage), StorageClass, + toStorage, + mkStorage, unStorage, + castToStorage, gTypeStorage, + StorageInfo(StorageInfo), StorageInfoClass, + toStorageInfo, + mkStorageInfo, unStorageInfo, + castToStorageInfo, gTypeStorageInfo, + StorageQuota(StorageQuota), StorageQuotaClass, + toStorageQuota, + mkStorageQuota, unStorageQuota, + castToStorageQuota, gTypeStorageQuota, + StyleMedia(StyleMedia), StyleMediaClass, + toStyleMedia, + mkStyleMedia, unStyleMedia, + castToStyleMedia, gTypeStyleMedia, + StyleSheet(StyleSheet), StyleSheetClass, + toStyleSheet, + mkStyleSheet, unStyleSheet, + castToStyleSheet, gTypeStyleSheet, + CSSStyleSheet(CSSStyleSheet), CSSStyleSheetClass, + toCSSStyleSheet, + mkCSSStyleSheet, unCSSStyleSheet, + castToCSSStyleSheet, gTypeCSSStyleSheet, + StyleSheetList(StyleSheetList), StyleSheetListClass, + toStyleSheetList, + mkStyleSheetList, unStyleSheetList, + castToStyleSheetList, gTypeStyleSheetList, + TextTrackCueList(TextTrackCueList), TextTrackCueListClass, + toTextTrackCueList, + mkTextTrackCueList, unTextTrackCueList, + castToTextTrackCueList, gTypeTextTrackCueList, + TimeRanges(TimeRanges), TimeRangesClass, + toTimeRanges, + mkTimeRanges, unTimeRanges, + castToTimeRanges, gTypeTimeRanges, + Touch(Touch), TouchClass, + toTouch, + mkTouch, unTouch, + castToTouch, gTypeTouch, + TreeWalker(TreeWalker), TreeWalkerClass, + toTreeWalker, + mkTreeWalker, unTreeWalker, + castToTreeWalker, gTypeTreeWalker, + ValidityState(ValidityState), ValidityStateClass, + toValidityState, + mkValidityState, unValidityState, + castToValidityState, gTypeValidityState, + VideoTrack(VideoTrack), VideoTrackClass, + toVideoTrack, + mkVideoTrack, unVideoTrack, + castToVideoTrack, gTypeVideoTrack, + WebKitPoint(WebKitPoint), WebKitPointClass, + toWebKitPoint, + mkWebKitPoint, unWebKitPoint, + castToWebKitPoint, gTypeWebKitPoint, + XPathExpression(XPathExpression), XPathExpressionClass, + toXPathExpression, + mkXPathExpression, unXPathExpression, + castToXPathExpression, gTypeXPathExpression, + XPathNSResolver(XPathNSResolver), XPathNSResolverClass, + toXPathNSResolver, + mkXPathNSResolver, unXPathNSResolver, + castToXPathNSResolver, gTypeXPathNSResolver, + XPathResult(XPathResult), XPathResultClass, + toXPathResult, + mkXPathResult, unXPathResult, + castToXPathResult, gTypeXPathResult + ) where + +import Foreign.ForeignPtr (ForeignPtr, castForeignPtr) +#if __GLASGOW_HASKELL__ >= 707 +import Foreign.ForeignPtr.Unsafe (unsafeForeignPtrToPtr) +#else +import Foreign.ForeignPtr (unsafeForeignPtrToPtr) +#endif +import Foreign.C.Types (CULong(..), CUInt(..), CULLong(..)) +import System.Glib.GType (GType, typeInstanceIsA) +import Graphics.UI.Gtk.WebKit.GtkInternals + +{# context lib="gtk" prefix="gtk" #} + +-- The usage of foreignPtrToPtr should be safe as the evaluation will only be +-- forced if the object is used afterwards +-- +castTo :: (GObjectClass obj, GObjectClass obj') => GType -> String + -> (obj -> obj') +castTo gtype objTypeName obj = + case toGObject obj of + gobj@(GObject objFPtr) + | typeInstanceIsA ((unsafeForeignPtrToPtr.castForeignPtr) objFPtr) gtype + -> unsafeCastGObject gobj + | otherwise -> error $ "Cannot cast object to " ++ objTypeName + + +-- ******************************************************************** WebView + +{#pointer *WebKitWebView as WebView foreign newtype #} deriving (Eq,Ord) + +mkWebView = (WebView, objectUnrefFromMainloop) +unWebView (WebView o) = o + +class ContainerClass o => WebViewClass o +toWebView :: WebViewClass o => o -> WebView +toWebView = unsafeCastGObject . toGObject + +instance WebViewClass WebView +instance ContainerClass WebView +instance WidgetClass WebView +instance GObjectClass WebView where + toGObject = GObject . castForeignPtr . unWebView + unsafeCastGObject = WebView . castForeignPtr . unGObject + +castToWebView :: GObjectClass obj => obj -> WebView +castToWebView = castTo gTypeWebView "WebView" + +gTypeWebView :: GType +gTypeWebView = + {# call fun unsafe webkit_web_view_get_type #} + +-- ******************************************************************* WebFrame + +{#pointer *WebKitWebFrame as WebFrame foreign newtype #} deriving (Eq,Ord) + +mkWebFrame = (WebFrame, objectUnrefFromMainloop) +unWebFrame (WebFrame o) = o + +class GObjectClass o => WebFrameClass o +toWebFrame :: WebFrameClass o => o -> WebFrame +toWebFrame = unsafeCastGObject . toGObject + +instance WebFrameClass WebFrame +instance GObjectClass WebFrame where + toGObject = GObject . castForeignPtr . unWebFrame + unsafeCastGObject = WebFrame . castForeignPtr . unGObject + +castToWebFrame :: GObjectClass obj => obj -> WebFrame +castToWebFrame = castTo gTypeWebFrame "WebFrame" + +gTypeWebFrame :: GType +gTypeWebFrame = + {# call fun unsafe webkit_web_frame_get_type #} + +-- **************************************************************** WebSettings + +{#pointer *WebKitWebSettings as WebSettings foreign newtype #} deriving (Eq,Ord) + +mkWebSettings = (WebSettings, objectUnrefFromMainloop) +unWebSettings (WebSettings o) = o + +class GObjectClass o => WebSettingsClass o +toWebSettings :: WebSettingsClass o => o -> WebSettings +toWebSettings = unsafeCastGObject . toGObject + +instance WebSettingsClass WebSettings +instance GObjectClass WebSettings where + toGObject = GObject . castForeignPtr . unWebSettings + unsafeCastGObject = WebSettings . castForeignPtr . unGObject + +castToWebSettings :: GObjectClass obj => obj -> WebSettings +castToWebSettings = castTo gTypeWebSettings "WebSettings" + +gTypeWebSettings :: GType +gTypeWebSettings = + {# call fun unsafe webkit_web_settings_get_type #} + +-- ************************************************************* NetworkRequest + +{#pointer *WebKitNetworkRequest as NetworkRequest foreign newtype #} deriving (Eq,Ord) + +mkNetworkRequest = (NetworkRequest, objectUnrefFromMainloop) +unNetworkRequest (NetworkRequest o) = o + +class GObjectClass o => NetworkRequestClass o +toNetworkRequest :: NetworkRequestClass o => o -> NetworkRequest +toNetworkRequest = unsafeCastGObject . toGObject + +instance NetworkRequestClass NetworkRequest +instance GObjectClass NetworkRequest where + toGObject = GObject . castForeignPtr . unNetworkRequest + unsafeCastGObject = NetworkRequest . castForeignPtr . unGObject + +castToNetworkRequest :: GObjectClass obj => obj -> NetworkRequest +castToNetworkRequest = castTo gTypeNetworkRequest "NetworkRequest" + +gTypeNetworkRequest :: GType +gTypeNetworkRequest = + {# call fun unsafe webkit_network_request_get_type #} + +-- ************************************************************ NetworkResponse + +{#pointer *WebKitNetworkResponse as NetworkResponse foreign newtype #} deriving (Eq,Ord) + +mkNetworkResponse = (NetworkResponse, objectUnrefFromMainloop) +unNetworkResponse (NetworkResponse o) = o + +class GObjectClass o => NetworkResponseClass o +toNetworkResponse :: NetworkResponseClass o => o -> NetworkResponse +toNetworkResponse = unsafeCastGObject . toGObject + +instance NetworkResponseClass NetworkResponse +instance GObjectClass NetworkResponse where + toGObject = GObject . castForeignPtr . unNetworkResponse + unsafeCastGObject = NetworkResponse . castForeignPtr . unGObject + +castToNetworkResponse :: GObjectClass obj => obj -> NetworkResponse +castToNetworkResponse = castTo gTypeNetworkResponse "NetworkResponse" + +gTypeNetworkResponse :: GType +gTypeNetworkResponse = + {# call fun unsafe webkit_network_response_get_type #} + +-- ******************************************************************* Download + +{#pointer *WebKitDownload as Download foreign newtype #} deriving (Eq,Ord) + +mkDownload = (Download, objectUnrefFromMainloop) +unDownload (Download o) = o + +class GObjectClass o => DownloadClass o +toDownload :: DownloadClass o => o -> Download +toDownload = unsafeCastGObject . toGObject + +instance DownloadClass Download +instance GObjectClass Download where + toGObject = GObject . castForeignPtr . unDownload + unsafeCastGObject = Download . castForeignPtr . unGObject + +castToDownload :: GObjectClass obj => obj -> Download +castToDownload = castTo gTypeDownload "Download" + +gTypeDownload :: GType +gTypeDownload = + {# call fun unsafe webkit_download_get_type #} + +-- ********************************************************* WebBackForwardList + +{#pointer *WebKitWebBackForwardList as WebBackForwardList foreign newtype #} deriving (Eq,Ord) + +mkWebBackForwardList = (WebBackForwardList, objectUnrefFromMainloop) +unWebBackForwardList (WebBackForwardList o) = o + +class GObjectClass o => WebBackForwardListClass o +toWebBackForwardList :: WebBackForwardListClass o => o -> WebBackForwardList +toWebBackForwardList = unsafeCastGObject . toGObject + +instance WebBackForwardListClass WebBackForwardList +instance GObjectClass WebBackForwardList where + toGObject = GObject . castForeignPtr . unWebBackForwardList + unsafeCastGObject = WebBackForwardList . castForeignPtr . unGObject + +castToWebBackForwardList :: GObjectClass obj => obj -> WebBackForwardList +castToWebBackForwardList = castTo gTypeWebBackForwardList "WebBackForwardList" + +gTypeWebBackForwardList :: GType +gTypeWebBackForwardList = + {# call fun unsafe webkit_web_back_forward_list_get_type #} + +-- ************************************************************* WebHistoryItem + +{#pointer *WebKitWebHistoryItem as WebHistoryItem foreign newtype #} deriving (Eq,Ord) + +mkWebHistoryItem = (WebHistoryItem, objectUnrefFromMainloop) +unWebHistoryItem (WebHistoryItem o) = o + +class GObjectClass o => WebHistoryItemClass o +toWebHistoryItem :: WebHistoryItemClass o => o -> WebHistoryItem +toWebHistoryItem = unsafeCastGObject . toGObject + +instance WebHistoryItemClass WebHistoryItem +instance GObjectClass WebHistoryItem where + toGObject = GObject . castForeignPtr . unWebHistoryItem + unsafeCastGObject = WebHistoryItem . castForeignPtr . unGObject + +castToWebHistoryItem :: GObjectClass obj => obj -> WebHistoryItem +castToWebHistoryItem = castTo gTypeWebHistoryItem "WebHistoryItem" + +gTypeWebHistoryItem :: GType +gTypeWebHistoryItem = + {# call fun unsafe webkit_web_history_item_get_type #} + +-- *************************************************************** WebInspector + +{#pointer *WebKitWebInspector as WebInspector foreign newtype #} deriving (Eq,Ord) + +mkWebInspector = (WebInspector, objectUnrefFromMainloop) +unWebInspector (WebInspector o) = o + +class GObjectClass o => WebInspectorClass o +toWebInspector :: WebInspectorClass o => o -> WebInspector +toWebInspector = unsafeCastGObject . toGObject + +instance WebInspectorClass WebInspector +instance GObjectClass WebInspector where + toGObject = GObject . castForeignPtr . unWebInspector + unsafeCastGObject = WebInspector . castForeignPtr . unGObject + +castToWebInspector :: GObjectClass obj => obj -> WebInspector +castToWebInspector = castTo gTypeWebInspector "WebInspector" + +gTypeWebInspector :: GType +gTypeWebInspector = + {# call fun unsafe webkit_web_inspector_get_type #} + +-- ************************************************************** HitTestResult + +{#pointer *WebKitHitTestResult as HitTestResult foreign newtype #} deriving (Eq,Ord) + +mkHitTestResult = (HitTestResult, objectUnrefFromMainloop) +unHitTestResult (HitTestResult o) = o + +class GObjectClass o => HitTestResultClass o +toHitTestResult :: HitTestResultClass o => o -> HitTestResult +toHitTestResult = unsafeCastGObject . toGObject + +instance HitTestResultClass HitTestResult +instance GObjectClass HitTestResult where + toGObject = GObject . castForeignPtr . unHitTestResult + unsafeCastGObject = HitTestResult . castForeignPtr . unGObject + +castToHitTestResult :: GObjectClass obj => obj -> HitTestResult +castToHitTestResult = castTo gTypeHitTestResult "HitTestResult" + +gTypeHitTestResult :: GType +gTypeHitTestResult = + {# call fun unsafe webkit_hit_test_result_get_type #} + +-- ************************************************************* SecurityOrigin + +{#pointer *WebKitSecurityOrigin as SecurityOrigin foreign newtype #} deriving (Eq,Ord) + +mkSecurityOrigin = (SecurityOrigin, objectUnrefFromMainloop) +unSecurityOrigin (SecurityOrigin o) = o + +class GObjectClass o => SecurityOriginClass o +toSecurityOrigin :: SecurityOriginClass o => o -> SecurityOrigin +toSecurityOrigin = unsafeCastGObject . toGObject + +instance SecurityOriginClass SecurityOrigin +instance GObjectClass SecurityOrigin where + toGObject = GObject . castForeignPtr . unSecurityOrigin + unsafeCastGObject = SecurityOrigin . castForeignPtr . unGObject + +castToSecurityOrigin :: GObjectClass obj => obj -> SecurityOrigin +castToSecurityOrigin = castTo gTypeSecurityOrigin "SecurityOrigin" + +gTypeSecurityOrigin :: GType +gTypeSecurityOrigin = + {# call fun unsafe webkit_security_origin_get_type #} + +-- ************************************************************* SoupAuthDialog + +{#pointer *WebKitSoupAuthDialog as SoupAuthDialog foreign newtype #} deriving (Eq,Ord) + +mkSoupAuthDialog = (SoupAuthDialog, objectUnrefFromMainloop) +unSoupAuthDialog (SoupAuthDialog o) = o + +class GObjectClass o => SoupAuthDialogClass o +toSoupAuthDialog :: SoupAuthDialogClass o => o -> SoupAuthDialog +toSoupAuthDialog = unsafeCastGObject . toGObject + +instance SoupAuthDialogClass SoupAuthDialog +instance GObjectClass SoupAuthDialog where + toGObject = GObject . castForeignPtr . unSoupAuthDialog + unsafeCastGObject = SoupAuthDialog . castForeignPtr . unGObject + +castToSoupAuthDialog :: GObjectClass obj => obj -> SoupAuthDialog +castToSoupAuthDialog = castTo gTypeSoupAuthDialog "SoupAuthDialog" + +gTypeSoupAuthDialog :: GType +gTypeSoupAuthDialog = + {# call fun unsafe webkit_soup_auth_dialog_get_type #} + +-- **************************************************************** WebDatabase + +{#pointer *WebKitWebDatabase as WebDatabase foreign newtype #} deriving (Eq,Ord) + +mkWebDatabase = (WebDatabase, objectUnrefFromMainloop) +unWebDatabase (WebDatabase o) = o + +class GObjectClass o => WebDatabaseClass o +toWebDatabase :: WebDatabaseClass o => o -> WebDatabase +toWebDatabase = unsafeCastGObject . toGObject + +instance WebDatabaseClass WebDatabase +instance GObjectClass WebDatabase where + toGObject = GObject . castForeignPtr . unWebDatabase + unsafeCastGObject = WebDatabase . castForeignPtr . unGObject + +castToWebDatabase :: GObjectClass obj => obj -> WebDatabase +castToWebDatabase = castTo gTypeWebDatabase "WebDatabase" + +gTypeWebDatabase :: GType +gTypeWebDatabase = + {# call fun unsafe webkit_web_database_get_type #} + +-- ************************************************************** WebDataSource + +{#pointer *WebKitWebDataSource as WebDataSource foreign newtype #} deriving (Eq,Ord) + +mkWebDataSource = (WebDataSource, objectUnrefFromMainloop) +unWebDataSource (WebDataSource o) = o + +class GObjectClass o => WebDataSourceClass o +toWebDataSource :: WebDataSourceClass o => o -> WebDataSource +toWebDataSource = unsafeCastGObject . toGObject + +instance WebDataSourceClass WebDataSource +instance GObjectClass WebDataSource where + toGObject = GObject . castForeignPtr . unWebDataSource + unsafeCastGObject = WebDataSource . castForeignPtr . unGObject + +castToWebDataSource :: GObjectClass obj => obj -> WebDataSource +castToWebDataSource = castTo gTypeWebDataSource "WebDataSource" + +gTypeWebDataSource :: GType +gTypeWebDataSource = + {# call fun unsafe webkit_web_data_source_get_type #} + +-- ******************************************************** WebNavigationAction + +{#pointer *WebKitWebNavigationAction as WebNavigationAction foreign newtype #} deriving (Eq,Ord) + +mkWebNavigationAction = (WebNavigationAction, objectUnrefFromMainloop) +unWebNavigationAction (WebNavigationAction o) = o + +class GObjectClass o => WebNavigationActionClass o +toWebNavigationAction :: WebNavigationActionClass o => o -> WebNavigationAction +toWebNavigationAction = unsafeCastGObject . toGObject + +instance WebNavigationActionClass WebNavigationAction +instance GObjectClass WebNavigationAction where + toGObject = GObject . castForeignPtr . unWebNavigationAction + unsafeCastGObject = WebNavigationAction . castForeignPtr . unGObject + +castToWebNavigationAction :: GObjectClass obj => obj -> WebNavigationAction +castToWebNavigationAction = castTo gTypeWebNavigationAction "WebNavigationAction" + +gTypeWebNavigationAction :: GType +gTypeWebNavigationAction = + {# call fun unsafe webkit_web_navigation_action_get_type #} + +-- ********************************************************** WebPolicyDecision + +{#pointer *WebKitWebPolicyDecision as WebPolicyDecision foreign newtype #} deriving (Eq,Ord) + +mkWebPolicyDecision = (WebPolicyDecision, objectUnrefFromMainloop) +unWebPolicyDecision (WebPolicyDecision o) = o + +class GObjectClass o => WebPolicyDecisionClass o +toWebPolicyDecision :: WebPolicyDecisionClass o => o -> WebPolicyDecision +toWebPolicyDecision = unsafeCastGObject . toGObject + +instance WebPolicyDecisionClass WebPolicyDecision +instance GObjectClass WebPolicyDecision where + toGObject = GObject . castForeignPtr . unWebPolicyDecision + unsafeCastGObject = WebPolicyDecision . castForeignPtr . unGObject + +castToWebPolicyDecision :: GObjectClass obj => obj -> WebPolicyDecision +castToWebPolicyDecision = castTo gTypeWebPolicyDecision "WebPolicyDecision" + +gTypeWebPolicyDecision :: GType +gTypeWebPolicyDecision = + {# call fun unsafe webkit_web_policy_decision_get_type #} + +-- **************************************************************** WebResource + +{#pointer *WebKitWebResource as WebResource foreign newtype #} deriving (Eq,Ord) + +mkWebResource = (WebResource, objectUnrefFromMainloop) +unWebResource (WebResource o) = o + +class GObjectClass o => WebResourceClass o +toWebResource :: WebResourceClass o => o -> WebResource +toWebResource = unsafeCastGObject . toGObject + +instance WebResourceClass WebResource +instance GObjectClass WebResource where + toGObject = GObject . castForeignPtr . unWebResource + unsafeCastGObject = WebResource . castForeignPtr . unGObject + +castToWebResource :: GObjectClass obj => obj -> WebResource +castToWebResource = castTo gTypeWebResource "WebResource" + +gTypeWebResource :: GType +gTypeWebResource = + {# call fun unsafe webkit_web_resource_get_type #} + +-- ********************************************************** WebWindowFeatures + +{#pointer *WebKitWebWindowFeatures as WebWindowFeatures foreign newtype #} deriving (Eq,Ord) + +mkWebWindowFeatures = (WebWindowFeatures, objectUnrefFromMainloop) +unWebWindowFeatures (WebWindowFeatures o) = o + +class GObjectClass o => WebWindowFeaturesClass o +toWebWindowFeatures :: WebWindowFeaturesClass o => o -> WebWindowFeatures +toWebWindowFeatures = unsafeCastGObject . toGObject + +instance WebWindowFeaturesClass WebWindowFeatures +instance GObjectClass WebWindowFeatures where + toGObject = GObject . castForeignPtr . unWebWindowFeatures + unsafeCastGObject = WebWindowFeatures . castForeignPtr . unGObject + +castToWebWindowFeatures :: GObjectClass obj => obj -> WebWindowFeatures +castToWebWindowFeatures = castTo gTypeWebWindowFeatures "WebWindowFeatures" + +gTypeWebWindowFeatures :: GType +gTypeWebWindowFeatures = + {# call fun unsafe webkit_web_window_features_get_type #} + +-- ************************************************** GeolocationPolicyDecision + +{#pointer *WebKitGeolocationPolicyDecision as GeolocationPolicyDecision foreign newtype #} deriving (Eq,Ord) + +mkGeolocationPolicyDecision = (GeolocationPolicyDecision, objectUnrefFromMainloop) +unGeolocationPolicyDecision (GeolocationPolicyDecision o) = o + +class GObjectClass o => GeolocationPolicyDecisionClass o +toGeolocationPolicyDecision :: GeolocationPolicyDecisionClass o => o -> GeolocationPolicyDecision +toGeolocationPolicyDecision = unsafeCastGObject . toGObject + +instance GeolocationPolicyDecisionClass GeolocationPolicyDecision +instance GObjectClass GeolocationPolicyDecision where + toGObject = GObject . castForeignPtr . unGeolocationPolicyDecision + unsafeCastGObject = GeolocationPolicyDecision . castForeignPtr . unGObject + +castToGeolocationPolicyDecision :: GObjectClass obj => obj -> GeolocationPolicyDecision +castToGeolocationPolicyDecision = castTo gTypeGeolocationPolicyDecision "GeolocationPolicyDecision" + +gTypeGeolocationPolicyDecision :: GType +gTypeGeolocationPolicyDecision = + {# call fun unsafe webkit_geolocation_policy_decision_get_type #} + +-- ***************************************************************** AudioTrack + +{#pointer *WebKitDOMAudioTrack as AudioTrack foreign newtype #} deriving (Eq,Ord) + +mkAudioTrack = (AudioTrack, objectUnrefFromMainloop) +unAudioTrack (AudioTrack o) = o + +class GObjectClass o => AudioTrackClass o +toAudioTrack :: AudioTrackClass o => o -> AudioTrack +toAudioTrack = unsafeCastGObject . toGObject + +instance AudioTrackClass AudioTrack +instance GObjectClass AudioTrack where + toGObject = GObject . castForeignPtr . unAudioTrack + unsafeCastGObject = AudioTrack . castForeignPtr . unGObject + +castToAudioTrack :: GObjectClass obj => obj -> AudioTrack +castToAudioTrack = castTo gTypeAudioTrack "AudioTrack" + +gTypeAudioTrack :: GType +gTypeAudioTrack = + {# call fun unsafe webkit_dom_audio_track_get_type #} + +-- ******************************************************************** BarProp + +{#pointer *WebKitDOMBarProp as BarProp foreign newtype #} deriving (Eq,Ord) + +mkBarProp = (BarProp, objectUnrefFromMainloop) +unBarProp (BarProp o) = o + +class GObjectClass o => BarPropClass o +toBarProp :: BarPropClass o => o -> BarProp +toBarProp = unsafeCastGObject . toGObject + +instance BarPropClass BarProp +instance GObjectClass BarProp where + toGObject = GObject . castForeignPtr . unBarProp + unsafeCastGObject = BarProp . castForeignPtr . unGObject + +castToBarProp :: GObjectClass obj => obj -> BarProp +castToBarProp = castTo gTypeBarProp "BarProp" + +gTypeBarProp :: GType +gTypeBarProp = + {# call fun unsafe webkit_dom_bar_prop_get_type #} + +-- *********************************************************************** Blob + +{#pointer *WebKitDOMBlob as Blob foreign newtype #} deriving (Eq,Ord) + +mkBlob = (Blob, objectUnrefFromMainloop) +unBlob (Blob o) = o + +class GObjectClass o => BlobClass o +toBlob :: BlobClass o => o -> Blob +toBlob = unsafeCastGObject . toGObject + +instance BlobClass Blob +instance GObjectClass Blob where + toGObject = GObject . castForeignPtr . unBlob + unsafeCastGObject = Blob . castForeignPtr . unGObject + +castToBlob :: GObjectClass obj => obj -> Blob +castToBlob = castTo gTypeBlob "Blob" + +gTypeBlob :: GType +gTypeBlob = + {# call fun unsafe webkit_dom_blob_get_type #} + +-- *********************************************************************** File + +{#pointer *WebKitDOMFile as File foreign newtype #} deriving (Eq,Ord) + +mkFile = (File, objectUnrefFromMainloop) +unFile (File o) = o + +class BlobClass o => FileClass o +toFile :: FileClass o => o -> File +toFile = unsafeCastGObject . toGObject + +instance FileClass File +instance BlobClass File +instance GObjectClass File where + toGObject = GObject . castForeignPtr . unFile + unsafeCastGObject = File . castForeignPtr . unGObject + +castToFile :: GObjectClass obj => obj -> File +castToFile = castTo gTypeFile "File" + +gTypeFile :: GType +gTypeFile = + {# call fun unsafe webkit_dom_file_get_type #} + +-- ************************************************************************ CSS + +{#pointer *WebKitDOMDOMWindowCSS as CSS foreign newtype #} deriving (Eq,Ord) + +mkCSS = (CSS, objectUnrefFromMainloop) +unCSS (CSS o) = o + +class GObjectClass o => CSSClass o +toCSS :: CSSClass o => o -> CSS +toCSS = unsafeCastGObject . toGObject + +instance CSSClass CSS +instance GObjectClass CSS where + toGObject = GObject . castForeignPtr . unCSS + unsafeCastGObject = CSS . castForeignPtr . unGObject + +castToCSS :: GObjectClass obj => obj -> CSS +castToCSS = castTo gTypeCSS "CSS" + +gTypeCSS :: GType +gTypeCSS = + {# call fun unsafe webkit_dom_dom_window_css_get_type #} + +-- ******************************************************************** CSSRule + +{#pointer *WebKitDOMCSSRule as CSSRule foreign newtype #} deriving (Eq,Ord) + +mkCSSRule = (CSSRule, objectUnrefFromMainloop) +unCSSRule (CSSRule o) = o + +class GObjectClass o => CSSRuleClass o +toCSSRule :: CSSRuleClass o => o -> CSSRule +toCSSRule = unsafeCastGObject . toGObject + +instance CSSRuleClass CSSRule +instance GObjectClass CSSRule where + toGObject = GObject . castForeignPtr . unCSSRule + unsafeCastGObject = CSSRule . castForeignPtr . unGObject + +castToCSSRule :: GObjectClass obj => obj -> CSSRule +castToCSSRule = castTo gTypeCSSRule "CSSRule" + +gTypeCSSRule :: GType +gTypeCSSRule = + {# call fun unsafe webkit_dom_css_rule_get_type #} + +-- **************************************************************** CSSRuleList + +{#pointer *WebKitDOMCSSRuleList as CSSRuleList foreign newtype #} deriving (Eq,Ord) + +mkCSSRuleList = (CSSRuleList, objectUnrefFromMainloop) +unCSSRuleList (CSSRuleList o) = o + +class GObjectClass o => CSSRuleListClass o +toCSSRuleList :: CSSRuleListClass o => o -> CSSRuleList +toCSSRuleList = unsafeCastGObject . toGObject + +instance CSSRuleListClass CSSRuleList +instance GObjectClass CSSRuleList where + toGObject = GObject . castForeignPtr . unCSSRuleList + unsafeCastGObject = CSSRuleList . castForeignPtr . unGObject + +castToCSSRuleList :: GObjectClass obj => obj -> CSSRuleList +castToCSSRuleList = castTo gTypeCSSRuleList "CSSRuleList" + +gTypeCSSRuleList :: GType +gTypeCSSRuleList = + {# call fun unsafe webkit_dom_css_rule_list_get_type #} + +-- ******************************************************** CSSStyleDeclaration + +{#pointer *WebKitDOMCSSStyleDeclaration as CSSStyleDeclaration foreign newtype #} deriving (Eq,Ord) + +mkCSSStyleDeclaration = (CSSStyleDeclaration, objectUnrefFromMainloop) +unCSSStyleDeclaration (CSSStyleDeclaration o) = o + +class GObjectClass o => CSSStyleDeclarationClass o +toCSSStyleDeclaration :: CSSStyleDeclarationClass o => o -> CSSStyleDeclaration +toCSSStyleDeclaration = unsafeCastGObject . toGObject + +instance CSSStyleDeclarationClass CSSStyleDeclaration +instance GObjectClass CSSStyleDeclaration where + toGObject = GObject . castForeignPtr . unCSSStyleDeclaration + unsafeCastGObject = CSSStyleDeclaration . castForeignPtr . unGObject + +castToCSSStyleDeclaration :: GObjectClass obj => obj -> CSSStyleDeclaration +castToCSSStyleDeclaration = castTo gTypeCSSStyleDeclaration "CSSStyleDeclaration" + +gTypeCSSStyleDeclaration :: GType +gTypeCSSStyleDeclaration = + {# call fun unsafe webkit_dom_css_style_declaration_get_type #} + +-- ******************************************************************* CSSValue + +{#pointer *WebKitDOMCSSValue as CSSValue foreign newtype #} deriving (Eq,Ord) + +mkCSSValue = (CSSValue, objectUnrefFromMainloop) +unCSSValue (CSSValue o) = o + +class GObjectClass o => CSSValueClass o +toCSSValue :: CSSValueClass o => o -> CSSValue +toCSSValue = unsafeCastGObject . toGObject + +instance CSSValueClass CSSValue +instance GObjectClass CSSValue where + toGObject = GObject . castForeignPtr . unCSSValue + unsafeCastGObject = CSSValue . castForeignPtr . unGObject + +castToCSSValue :: GObjectClass obj => obj -> CSSValue +castToCSSValue = castTo gTypeCSSValue "CSSValue" + +gTypeCSSValue :: GType +gTypeCSSValue = + {# call fun unsafe webkit_dom_css_value_get_type #} + +-- ********************************************************** DOMImplementation + +{#pointer *WebKitDOMDOMImplementation as DOMImplementation foreign newtype #} deriving (Eq,Ord) + +mkDOMImplementation = (DOMImplementation, objectUnrefFromMainloop) +unDOMImplementation (DOMImplementation o) = o + +class GObjectClass o => DOMImplementationClass o +toDOMImplementation :: DOMImplementationClass o => o -> DOMImplementation +toDOMImplementation = unsafeCastGObject . toGObject + +instance DOMImplementationClass DOMImplementation +instance GObjectClass DOMImplementation where + toGObject = GObject . castForeignPtr . unDOMImplementation + unsafeCastGObject = DOMImplementation . castForeignPtr . unGObject + +castToDOMImplementation :: GObjectClass obj => obj -> DOMImplementation +castToDOMImplementation = castTo gTypeDOMImplementation "DOMImplementation" + +gTypeDOMImplementation :: GType +gTypeDOMImplementation = + {# call fun unsafe webkit_dom_dom_implementation_get_type #} + +-- ***************************************************** DOMNamedFlowCollection + +{#pointer *WebKitDOMDOMNamedFlowCollection as DOMNamedFlowCollection foreign newtype #} deriving (Eq,Ord) + +mkDOMNamedFlowCollection = (DOMNamedFlowCollection, objectUnrefFromMainloop) +unDOMNamedFlowCollection (DOMNamedFlowCollection o) = o + +class GObjectClass o => DOMNamedFlowCollectionClass o +toDOMNamedFlowCollection :: DOMNamedFlowCollectionClass o => o -> DOMNamedFlowCollection +toDOMNamedFlowCollection = unsafeCastGObject . toGObject + +instance DOMNamedFlowCollectionClass DOMNamedFlowCollection +instance GObjectClass DOMNamedFlowCollection where + toGObject = GObject . castForeignPtr . unDOMNamedFlowCollection + unsafeCastGObject = DOMNamedFlowCollection . castForeignPtr . unGObject + +castToDOMNamedFlowCollection :: GObjectClass obj => obj -> DOMNamedFlowCollection +castToDOMNamedFlowCollection = castTo gTypeDOMNamedFlowCollection "DOMNamedFlowCollection" + +gTypeDOMNamedFlowCollection :: GType +gTypeDOMNamedFlowCollection = + {# call fun unsafe webkit_dom_dom_named_flow_collection_get_type #} + +-- ************************************************************** DOMStringList + +{#pointer *WebKitDOMDOMStringList as DOMStringList foreign newtype #} deriving (Eq,Ord) + +mkDOMStringList = (DOMStringList, objectUnrefFromMainloop) +unDOMStringList (DOMStringList o) = o + +class GObjectClass o => DOMStringListClass o +toDOMStringList :: DOMStringListClass o => o -> DOMStringList +toDOMStringList = unsafeCastGObject . toGObject + +instance DOMStringListClass DOMStringList +instance GObjectClass DOMStringList where + toGObject = GObject . castForeignPtr . unDOMStringList + unsafeCastGObject = DOMStringList . castForeignPtr . unGObject + +castToDOMStringList :: GObjectClass obj => obj -> DOMStringList +castToDOMStringList = castTo gTypeDOMStringList "DOMStringList" + +gTypeDOMStringList :: GType +gTypeDOMStringList = + {# call fun unsafe webkit_dom_dom_string_list_get_type #} + +-- *************************************************************** DOMTokenList + +{#pointer *WebKitDOMDOMTokenList as DOMTokenList foreign newtype #} deriving (Eq,Ord) + +mkDOMTokenList = (DOMTokenList, objectUnrefFromMainloop) +unDOMTokenList (DOMTokenList o) = o + +class GObjectClass o => DOMTokenListClass o +toDOMTokenList :: DOMTokenListClass o => o -> DOMTokenList +toDOMTokenList = unsafeCastGObject . toGObject + +instance DOMTokenListClass DOMTokenList +instance GObjectClass DOMTokenList where + toGObject = GObject . castForeignPtr . unDOMTokenList + unsafeCastGObject = DOMTokenList . castForeignPtr . unGObject + +castToDOMTokenList :: GObjectClass obj => obj -> DOMTokenList +castToDOMTokenList = castTo gTypeDOMTokenList "DOMTokenList" + +gTypeDOMTokenList :: GType +gTypeDOMTokenList = + {# call fun unsafe webkit_dom_dom_token_list_get_type #} + +-- ******************************************************* DOMSettableTokenList + +{#pointer *WebKitDOMDOMSettableTokenList as DOMSettableTokenList foreign newtype #} deriving (Eq,Ord) + +mkDOMSettableTokenList = (DOMSettableTokenList, objectUnrefFromMainloop) +unDOMSettableTokenList (DOMSettableTokenList o) = o + +class DOMTokenListClass o => DOMSettableTokenListClass o +toDOMSettableTokenList :: DOMSettableTokenListClass o => o -> DOMSettableTokenList +toDOMSettableTokenList = unsafeCastGObject . toGObject + +instance DOMSettableTokenListClass DOMSettableTokenList +instance DOMTokenListClass DOMSettableTokenList +instance GObjectClass DOMSettableTokenList where + toGObject = GObject . castForeignPtr . unDOMSettableTokenList + unsafeCastGObject = DOMSettableTokenList . castForeignPtr . unGObject + +castToDOMSettableTokenList :: GObjectClass obj => obj -> DOMSettableTokenList +castToDOMSettableTokenList = castTo gTypeDOMSettableTokenList "DOMSettableTokenList" + +gTypeDOMSettableTokenList :: GType +gTypeDOMSettableTokenList = + {# call fun unsafe webkit_dom_dom_settable_token_list_get_type #} + +-- ********************************************************************** Event + +{#pointer *WebKitDOMEvent as Event foreign newtype #} deriving (Eq,Ord) + +mkEvent = (Event, objectUnrefFromMainloop) +unEvent (Event o) = o + +class GObjectClass o => EventClass o +toEvent :: EventClass o => o -> Event +toEvent = unsafeCastGObject . toGObject + +instance EventClass Event +instance GObjectClass Event where + toGObject = GObject . castForeignPtr . unEvent + unsafeCastGObject = Event . castForeignPtr . unGObject + +castToEvent :: GObjectClass obj => obj -> Event +castToEvent = castTo gTypeEvent "Event" + +gTypeEvent :: GType +gTypeEvent = + {# call fun unsafe webkit_dom_event_get_type #} + +-- ******************************************************************** UIEvent + +{#pointer *WebKitDOMUIEvent as UIEvent foreign newtype #} deriving (Eq,Ord) + +mkUIEvent = (UIEvent, objectUnrefFromMainloop) +unUIEvent (UIEvent o) = o + +class EventClass o => UIEventClass o +toUIEvent :: UIEventClass o => o -> UIEvent +toUIEvent = unsafeCastGObject . toGObject + +instance UIEventClass UIEvent +instance EventClass UIEvent +instance GObjectClass UIEvent where + toGObject = GObject . castForeignPtr . unUIEvent + unsafeCastGObject = UIEvent . castForeignPtr . unGObject + +castToUIEvent :: GObjectClass obj => obj -> UIEvent +castToUIEvent = castTo gTypeUIEvent "UIEvent" + +gTypeUIEvent :: GType +gTypeUIEvent = + {# call fun unsafe webkit_dom_ui_event_get_type #} + +-- ************************************************************** KeyboardEvent + +{#pointer *WebKitDOMKeyboardEvent as KeyboardEvent foreign newtype #} deriving (Eq,Ord) + +mkKeyboardEvent = (KeyboardEvent, objectUnrefFromMainloop) +unKeyboardEvent (KeyboardEvent o) = o + +class UIEventClass o => KeyboardEventClass o +toKeyboardEvent :: KeyboardEventClass o => o -> KeyboardEvent +toKeyboardEvent = unsafeCastGObject . toGObject + +instance KeyboardEventClass KeyboardEvent +instance UIEventClass KeyboardEvent +instance EventClass KeyboardEvent +instance GObjectClass KeyboardEvent where + toGObject = GObject . castForeignPtr . unKeyboardEvent + unsafeCastGObject = KeyboardEvent . castForeignPtr . unGObject + +castToKeyboardEvent :: GObjectClass obj => obj -> KeyboardEvent +castToKeyboardEvent = castTo gTypeKeyboardEvent "KeyboardEvent" + +gTypeKeyboardEvent :: GType +gTypeKeyboardEvent = + {# call fun unsafe webkit_dom_keyboard_event_get_type #} + +-- ***************************************************************** MouseEvent + +{#pointer *WebKitDOMMouseEvent as MouseEvent foreign newtype #} deriving (Eq,Ord) + +mkMouseEvent = (MouseEvent, objectUnrefFromMainloop) +unMouseEvent (MouseEvent o) = o + +class UIEventClass o => MouseEventClass o +toMouseEvent :: MouseEventClass o => o -> MouseEvent +toMouseEvent = unsafeCastGObject . toGObject + +instance MouseEventClass MouseEvent +instance UIEventClass MouseEvent +instance EventClass MouseEvent +instance GObjectClass MouseEvent where + toGObject = GObject . castForeignPtr . unMouseEvent + unsafeCastGObject = MouseEvent . castForeignPtr . unGObject + +castToMouseEvent :: GObjectClass obj => obj -> MouseEvent +castToMouseEvent = castTo gTypeMouseEvent "MouseEvent" + +gTypeMouseEvent :: GType +gTypeMouseEvent = + {# call fun unsafe webkit_dom_mouse_event_get_type #} + +-- ***************************************************************** WheelEvent + +{#pointer *WebKitDOMWheelEvent as WheelEvent foreign newtype #} deriving (Eq,Ord) + +mkWheelEvent = (WheelEvent, objectUnrefFromMainloop) +unWheelEvent (WheelEvent o) = o + +class MouseEventClass o => WheelEventClass o +toWheelEvent :: WheelEventClass o => o -> WheelEvent +toWheelEvent = unsafeCastGObject . toGObject + +instance WheelEventClass WheelEvent +instance MouseEventClass WheelEvent +instance UIEventClass WheelEvent +instance EventClass WheelEvent +instance GObjectClass WheelEvent where + toGObject = GObject . castForeignPtr . unWheelEvent + unsafeCastGObject = WheelEvent . castForeignPtr . unGObject + +castToWheelEvent :: GObjectClass obj => obj -> WheelEvent +castToWheelEvent = castTo gTypeWheelEvent "WheelEvent" + +gTypeWheelEvent :: GType +gTypeWheelEvent = + {# call fun unsafe webkit_dom_wheel_event_get_type #} + +-- **************************************************************** EventTarget + +{#pointer *WebKitDOMEventTarget as EventTarget foreign newtype #} deriving (Eq,Ord) + +mkEventTarget = (EventTarget, objectUnrefFromMainloop) +unEventTarget (EventTarget o) = o + +class GObjectClass o => EventTargetClass o +toEventTarget :: EventTargetClass o => o -> EventTarget +toEventTarget = unsafeCastGObject . toGObject + +instance EventTargetClass EventTarget +instance GObjectClass EventTarget where + toGObject = GObject . castForeignPtr . unEventTarget + unsafeCastGObject = EventTarget . castForeignPtr . unGObject + +castToEventTarget :: GObjectClass obj => obj -> EventTarget +castToEventTarget = castTo gTypeEventTarget "EventTarget" + +gTypeEventTarget :: GType +gTypeEventTarget = + {# call fun unsafe webkit_dom_event_target_get_type #} + +-- *********************************************************** ApplicationCache + +{#pointer *WebKitDOMDOMApplicationCache as ApplicationCache foreign newtype #} deriving (Eq,Ord) + +mkApplicationCache = (ApplicationCache, objectUnrefFromMainloop) +unApplicationCache (ApplicationCache o) = o + +class EventTargetClass o => ApplicationCacheClass o +toApplicationCache :: ApplicationCacheClass o => o -> ApplicationCache +toApplicationCache = unsafeCastGObject . toGObject + +instance ApplicationCacheClass ApplicationCache +instance EventTargetClass ApplicationCache +instance GObjectClass ApplicationCache where + toGObject = GObject . castForeignPtr . unApplicationCache + unsafeCastGObject = ApplicationCache . castForeignPtr . unGObject + +castToApplicationCache :: GObjectClass obj => obj -> ApplicationCache +castToApplicationCache = castTo gTypeApplicationCache "ApplicationCache" + +gTypeApplicationCache :: GType +gTypeApplicationCache = + {# call fun unsafe webkit_dom_dom_application_cache_get_type #} + +-- ************************************************************* AudioTrackList + +{#pointer *WebKitDOMAudioTrackList as AudioTrackList foreign newtype #} deriving (Eq,Ord) + +mkAudioTrackList = (AudioTrackList, objectUnrefFromMainloop) +unAudioTrackList (AudioTrackList o) = o + +class EventTargetClass o => AudioTrackListClass o +toAudioTrackList :: AudioTrackListClass o => o -> AudioTrackList +toAudioTrackList = unsafeCastGObject . toGObject + +instance AudioTrackListClass AudioTrackList +instance EventTargetClass AudioTrackList +instance GObjectClass AudioTrackList where + toGObject = GObject . castForeignPtr . unAudioTrackList + unsafeCastGObject = AudioTrackList . castForeignPtr . unGObject + +castToAudioTrackList :: GObjectClass obj => obj -> AudioTrackList +castToAudioTrackList = castTo gTypeAudioTrackList "AudioTrackList" + +gTypeAudioTrackList :: GType +gTypeAudioTrackList = + {# call fun unsafe webkit_dom_audio_track_list_get_type #} + +-- ************************************************************* BatteryManager + +{#pointer *WebKitDOMBatteryManager as BatteryManager foreign newtype #} deriving (Eq,Ord) + +mkBatteryManager = (BatteryManager, objectUnrefFromMainloop) +unBatteryManager (BatteryManager o) = o + +class EventTargetClass o => BatteryManagerClass o +toBatteryManager :: BatteryManagerClass o => o -> BatteryManager +toBatteryManager = unsafeCastGObject . toGObject + +instance BatteryManagerClass BatteryManager +instance EventTargetClass BatteryManager +instance GObjectClass BatteryManager where + toGObject = GObject . castForeignPtr . unBatteryManager + unsafeCastGObject = BatteryManager . castForeignPtr . unGObject + +castToBatteryManager :: GObjectClass obj => obj -> BatteryManager +castToBatteryManager = castTo gTypeBatteryManager "BatteryManager" + +gTypeBatteryManager :: GType +gTypeBatteryManager = + {# call fun unsafe webkit_dom_battery_manager_get_type #} + +-- **************************************************************** MessagePort + +{#pointer *WebKitDOMMessagePort as MessagePort foreign newtype #} deriving (Eq,Ord) + +mkMessagePort = (MessagePort, objectUnrefFromMainloop) +unMessagePort (MessagePort o) = o + +class EventTargetClass o => MessagePortClass o +toMessagePort :: MessagePortClass o => o -> MessagePort +toMessagePort = unsafeCastGObject . toGObject + +instance MessagePortClass MessagePort +instance EventTargetClass MessagePort +instance GObjectClass MessagePort where + toGObject = GObject . castForeignPtr . unMessagePort + unsafeCastGObject = MessagePort . castForeignPtr . unGObject + +castToMessagePort :: GObjectClass obj => obj -> MessagePort +castToMessagePort = castTo gTypeMessagePort "MessagePort" + +gTypeMessagePort :: GType +gTypeMessagePort = + {# call fun unsafe webkit_dom_message_port_get_type #} + +-- *********************************************************************** Node + +{#pointer *WebKitDOMNode as Node foreign newtype #} deriving (Eq,Ord) + +mkNode = (Node, objectUnrefFromMainloop) +unNode (Node o) = o + +class EventTargetClass o => NodeClass o +toNode :: NodeClass o => o -> Node +toNode = unsafeCastGObject . toGObject + +instance NodeClass Node +instance EventTargetClass Node +instance GObjectClass Node where + toGObject = GObject . castForeignPtr . unNode + unsafeCastGObject = Node . castForeignPtr . unGObject + +castToNode :: GObjectClass obj => obj -> Node +castToNode = castTo gTypeNode "Node" + +gTypeNode :: GType +gTypeNode = + {# call fun unsafe webkit_dom_node_get_type #} + +-- *********************************************************************** Attr + +{#pointer *WebKitDOMAttr as Attr foreign newtype #} deriving (Eq,Ord) + +mkAttr = (Attr, objectUnrefFromMainloop) +unAttr (Attr o) = o + +class NodeClass o => AttrClass o +toAttr :: AttrClass o => o -> Attr +toAttr = unsafeCastGObject . toGObject + +instance AttrClass Attr +instance NodeClass Attr +instance EventTargetClass Attr +instance GObjectClass Attr where + toGObject = GObject . castForeignPtr . unAttr + unsafeCastGObject = Attr . castForeignPtr . unGObject + +castToAttr :: GObjectClass obj => obj -> Attr +castToAttr = castTo gTypeAttr "Attr" + +gTypeAttr :: GType +gTypeAttr = + {# call fun unsafe webkit_dom_attr_get_type #} + +-- ************************************************************** CharacterData + +{#pointer *WebKitDOMCharacterData as CharacterData foreign newtype #} deriving (Eq,Ord) + +mkCharacterData = (CharacterData, objectUnrefFromMainloop) +unCharacterData (CharacterData o) = o + +class NodeClass o => CharacterDataClass o +toCharacterData :: CharacterDataClass o => o -> CharacterData +toCharacterData = unsafeCastGObject . toGObject + +instance CharacterDataClass CharacterData +instance NodeClass CharacterData +instance EventTargetClass CharacterData +instance GObjectClass CharacterData where + toGObject = GObject . castForeignPtr . unCharacterData + unsafeCastGObject = CharacterData . castForeignPtr . unGObject + +castToCharacterData :: GObjectClass obj => obj -> CharacterData +castToCharacterData = castTo gTypeCharacterData "CharacterData" + +gTypeCharacterData :: GType +gTypeCharacterData = + {# call fun unsafe webkit_dom_character_data_get_type #} + +-- ******************************************************************** Comment + +{#pointer *WebKitDOMComment as Comment foreign newtype #} deriving (Eq,Ord) + +mkComment = (Comment, objectUnrefFromMainloop) +unComment (Comment o) = o + +class CharacterDataClass o => CommentClass o +toComment :: CommentClass o => o -> Comment +toComment = unsafeCastGObject . toGObject + +instance CommentClass Comment +instance CharacterDataClass Comment +instance NodeClass Comment +instance EventTargetClass Comment +instance GObjectClass Comment where + toGObject = GObject . castForeignPtr . unComment + unsafeCastGObject = Comment . castForeignPtr . unGObject + +castToComment :: GObjectClass obj => obj -> Comment +castToComment = castTo gTypeComment "Comment" + +gTypeComment :: GType +gTypeComment = + {# call fun unsafe webkit_dom_comment_get_type #} + +-- ****************************************************** ProcessingInstruction + +{#pointer *WebKitDOMProcessingInstruction as ProcessingInstruction foreign newtype #} deriving (Eq,Ord) + +mkProcessingInstruction = (ProcessingInstruction, objectUnrefFromMainloop) +unProcessingInstruction (ProcessingInstruction o) = o + +class CharacterDataClass o => ProcessingInstructionClass o +toProcessingInstruction :: ProcessingInstructionClass o => o -> ProcessingInstruction +toProcessingInstruction = unsafeCastGObject . toGObject + +instance ProcessingInstructionClass ProcessingInstruction +instance CharacterDataClass ProcessingInstruction +instance NodeClass ProcessingInstruction +instance EventTargetClass ProcessingInstruction +instance GObjectClass ProcessingInstruction where + toGObject = GObject . castForeignPtr . unProcessingInstruction + unsafeCastGObject = ProcessingInstruction . castForeignPtr . unGObject + +castToProcessingInstruction :: GObjectClass obj => obj -> ProcessingInstruction +castToProcessingInstruction = castTo gTypeProcessingInstruction "ProcessingInstruction" + +gTypeProcessingInstruction :: GType +gTypeProcessingInstruction = + {# call fun unsafe webkit_dom_processing_instruction_get_type #} + +-- *********************************************************************** Text + +{#pointer *WebKitDOMText as Text foreign newtype #} deriving (Eq,Ord) + +mkText = (Text, objectUnrefFromMainloop) +unText (Text o) = o + +class CharacterDataClass o => TextClass o +toText :: TextClass o => o -> Text +toText = unsafeCastGObject . toGObject + +instance TextClass Text +instance CharacterDataClass Text +instance NodeClass Text +instance EventTargetClass Text +instance GObjectClass Text where + toGObject = GObject . castForeignPtr . unText + unsafeCastGObject = Text . castForeignPtr . unGObject + +castToText :: GObjectClass obj => obj -> Text +castToText = castTo gTypeText "Text" + +gTypeText :: GType +gTypeText = + {# call fun unsafe webkit_dom_text_get_type #} + +-- *************************************************************** CDATASection + +{#pointer *WebKitDOMCDATASection as CDATASection foreign newtype #} deriving (Eq,Ord) + +mkCDATASection = (CDATASection, objectUnrefFromMainloop) +unCDATASection (CDATASection o) = o + +class TextClass o => CDATASectionClass o +toCDATASection :: CDATASectionClass o => o -> CDATASection +toCDATASection = unsafeCastGObject . toGObject + +instance CDATASectionClass CDATASection +instance TextClass CDATASection +instance CharacterDataClass CDATASection +instance NodeClass CDATASection +instance EventTargetClass CDATASection +instance GObjectClass CDATASection where + toGObject = GObject . castForeignPtr . unCDATASection + unsafeCastGObject = CDATASection . castForeignPtr . unGObject + +castToCDATASection :: GObjectClass obj => obj -> CDATASection +castToCDATASection = castTo gTypeCDATASection "CDATASection" + +gTypeCDATASection :: GType +gTypeCDATASection = + {# call fun unsafe webkit_dom_cdata_section_get_type #} + +-- ******************************************************************* Document + +{#pointer *WebKitDOMDocument as Document foreign newtype #} deriving (Eq,Ord) + +mkDocument = (Document, objectUnrefFromMainloop) +unDocument (Document o) = o + +class NodeClass o => DocumentClass o +toDocument :: DocumentClass o => o -> Document +toDocument = unsafeCastGObject . toGObject + +instance DocumentClass Document +instance NodeClass Document +instance EventTargetClass Document +instance GObjectClass Document where + toGObject = GObject . castForeignPtr . unDocument + unsafeCastGObject = Document . castForeignPtr . unGObject + +castToDocument :: GObjectClass obj => obj -> Document +castToDocument = castTo gTypeDocument "Document" + +gTypeDocument :: GType +gTypeDocument = + {# call fun unsafe webkit_dom_document_get_type #} + +-- *************************************************************** HTMLDocument + +{#pointer *WebKitDOMHTMLDocument as HTMLDocument foreign newtype #} deriving (Eq,Ord) + +mkHTMLDocument = (HTMLDocument, objectUnrefFromMainloop) +unHTMLDocument (HTMLDocument o) = o + +class DocumentClass o => HTMLDocumentClass o +toHTMLDocument :: HTMLDocumentClass o => o -> HTMLDocument +toHTMLDocument = unsafeCastGObject . toGObject + +instance HTMLDocumentClass HTMLDocument +instance DocumentClass HTMLDocument +instance NodeClass HTMLDocument +instance EventTargetClass HTMLDocument +instance GObjectClass HTMLDocument where + toGObject = GObject . castForeignPtr . unHTMLDocument + unsafeCastGObject = HTMLDocument . castForeignPtr . unGObject + +castToHTMLDocument :: GObjectClass obj => obj -> HTMLDocument +castToHTMLDocument = castTo gTypeHTMLDocument "HTMLDocument" + +gTypeHTMLDocument :: GType +gTypeHTMLDocument = + {# call fun unsafe webkit_dom_html_document_get_type #} + +-- *********************************************************** DocumentFragment + +{#pointer *WebKitDOMDocumentFragment as DocumentFragment foreign newtype #} deriving (Eq,Ord) + +mkDocumentFragment = (DocumentFragment, objectUnrefFromMainloop) +unDocumentFragment (DocumentFragment o) = o + +class NodeClass o => DocumentFragmentClass o +toDocumentFragment :: DocumentFragmentClass o => o -> DocumentFragment +toDocumentFragment = unsafeCastGObject . toGObject + +instance DocumentFragmentClass DocumentFragment +instance NodeClass DocumentFragment +instance EventTargetClass DocumentFragment +instance GObjectClass DocumentFragment where + toGObject = GObject . castForeignPtr . unDocumentFragment + unsafeCastGObject = DocumentFragment . castForeignPtr . unGObject + +castToDocumentFragment :: GObjectClass obj => obj -> DocumentFragment +castToDocumentFragment = castTo gTypeDocumentFragment "DocumentFragment" + +gTypeDocumentFragment :: GType +gTypeDocumentFragment = + {# call fun unsafe webkit_dom_document_fragment_get_type #} + +-- *************************************************************** DocumentType + +{#pointer *WebKitDOMDocumentType as DocumentType foreign newtype #} deriving (Eq,Ord) + +mkDocumentType = (DocumentType, objectUnrefFromMainloop) +unDocumentType (DocumentType o) = o + +class NodeClass o => DocumentTypeClass o +toDocumentType :: DocumentTypeClass o => o -> DocumentType +toDocumentType = unsafeCastGObject . toGObject + +instance DocumentTypeClass DocumentType +instance NodeClass DocumentType +instance EventTargetClass DocumentType +instance GObjectClass DocumentType where + toGObject = GObject . castForeignPtr . unDocumentType + unsafeCastGObject = DocumentType . castForeignPtr . unGObject + +castToDocumentType :: GObjectClass obj => obj -> DocumentType +castToDocumentType = castTo gTypeDocumentType "DocumentType" + +gTypeDocumentType :: GType +gTypeDocumentType = + {# call fun unsafe webkit_dom_document_type_get_type #} + +-- ******************************************************************** Element + +{#pointer *WebKitDOMElement as Element foreign newtype #} deriving (Eq,Ord) + +mkElement = (Element, objectUnrefFromMainloop) +unElement (Element o) = o + +class NodeClass o => ElementClass o +toElement :: ElementClass o => o -> Element +toElement = unsafeCastGObject . toGObject + +instance ElementClass Element +instance NodeClass Element +instance EventTargetClass Element +instance GObjectClass Element where + toGObject = GObject . castForeignPtr . unElement + unsafeCastGObject = Element . castForeignPtr . unGObject + +castToElement :: GObjectClass obj => obj -> Element +castToElement = castTo gTypeElement "Element" + +gTypeElement :: GType +gTypeElement = + {# call fun unsafe webkit_dom_element_get_type #} + +-- **************************************************************** HTMLElement + +{#pointer *WebKitDOMHTMLElement as HTMLElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLElement = (HTMLElement, objectUnrefFromMainloop) +unHTMLElement (HTMLElement o) = o + +class ElementClass o => HTMLElementClass o +toHTMLElement :: HTMLElementClass o => o -> HTMLElement +toHTMLElement = unsafeCastGObject . toGObject + +instance HTMLElementClass HTMLElement +instance ElementClass HTMLElement +instance NodeClass HTMLElement +instance EventTargetClass HTMLElement +instance GObjectClass HTMLElement where + toGObject = GObject . castForeignPtr . unHTMLElement + unsafeCastGObject = HTMLElement . castForeignPtr . unGObject + +castToHTMLElement :: GObjectClass obj => obj -> HTMLElement +castToHTMLElement = castTo gTypeHTMLElement "HTMLElement" + +gTypeHTMLElement :: GType +gTypeHTMLElement = + {# call fun unsafe webkit_dom_html_element_get_type #} + +-- ********************************************************** HTMLAnchorElement + +{#pointer *WebKitDOMHTMLAnchorElement as HTMLAnchorElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLAnchorElement = (HTMLAnchorElement, objectUnrefFromMainloop) +unHTMLAnchorElement (HTMLAnchorElement o) = o + +class HTMLElementClass o => HTMLAnchorElementClass o +toHTMLAnchorElement :: HTMLAnchorElementClass o => o -> HTMLAnchorElement +toHTMLAnchorElement = unsafeCastGObject . toGObject + +instance HTMLAnchorElementClass HTMLAnchorElement +instance HTMLElementClass HTMLAnchorElement +instance ElementClass HTMLAnchorElement +instance NodeClass HTMLAnchorElement +instance EventTargetClass HTMLAnchorElement +instance GObjectClass HTMLAnchorElement where + toGObject = GObject . castForeignPtr . unHTMLAnchorElement + unsafeCastGObject = HTMLAnchorElement . castForeignPtr . unGObject + +castToHTMLAnchorElement :: GObjectClass obj => obj -> HTMLAnchorElement +castToHTMLAnchorElement = castTo gTypeHTMLAnchorElement "HTMLAnchorElement" + +gTypeHTMLAnchorElement :: GType +gTypeHTMLAnchorElement = + {# call fun unsafe webkit_dom_html_anchor_element_get_type #} + +-- ********************************************************** HTMLAppletElement + +{#pointer *WebKitDOMHTMLAppletElement as HTMLAppletElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLAppletElement = (HTMLAppletElement, objectUnrefFromMainloop) +unHTMLAppletElement (HTMLAppletElement o) = o + +class HTMLElementClass o => HTMLAppletElementClass o +toHTMLAppletElement :: HTMLAppletElementClass o => o -> HTMLAppletElement +toHTMLAppletElement = unsafeCastGObject . toGObject + +instance HTMLAppletElementClass HTMLAppletElement +instance HTMLElementClass HTMLAppletElement +instance ElementClass HTMLAppletElement +instance NodeClass HTMLAppletElement +instance EventTargetClass HTMLAppletElement +instance GObjectClass HTMLAppletElement where + toGObject = GObject . castForeignPtr . unHTMLAppletElement + unsafeCastGObject = HTMLAppletElement . castForeignPtr . unGObject + +castToHTMLAppletElement :: GObjectClass obj => obj -> HTMLAppletElement +castToHTMLAppletElement = castTo gTypeHTMLAppletElement "HTMLAppletElement" + +gTypeHTMLAppletElement :: GType +gTypeHTMLAppletElement = + {# call fun unsafe webkit_dom_html_applet_element_get_type #} + +-- ************************************************************ HTMLAreaElement + +{#pointer *WebKitDOMHTMLAreaElement as HTMLAreaElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLAreaElement = (HTMLAreaElement, objectUnrefFromMainloop) +unHTMLAreaElement (HTMLAreaElement o) = o + +class HTMLElementClass o => HTMLAreaElementClass o +toHTMLAreaElement :: HTMLAreaElementClass o => o -> HTMLAreaElement +toHTMLAreaElement = unsafeCastGObject . toGObject + +instance HTMLAreaElementClass HTMLAreaElement +instance HTMLElementClass HTMLAreaElement +instance ElementClass HTMLAreaElement +instance NodeClass HTMLAreaElement +instance EventTargetClass HTMLAreaElement +instance GObjectClass HTMLAreaElement where + toGObject = GObject . castForeignPtr . unHTMLAreaElement + unsafeCastGObject = HTMLAreaElement . castForeignPtr . unGObject + +castToHTMLAreaElement :: GObjectClass obj => obj -> HTMLAreaElement +castToHTMLAreaElement = castTo gTypeHTMLAreaElement "HTMLAreaElement" + +gTypeHTMLAreaElement :: GType +gTypeHTMLAreaElement = + {# call fun unsafe webkit_dom_html_area_element_get_type #} + +-- ************************************************************** HTMLBRElement + +{#pointer *WebKitDOMHTMLBRElement as HTMLBRElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLBRElement = (HTMLBRElement, objectUnrefFromMainloop) +unHTMLBRElement (HTMLBRElement o) = o + +class HTMLElementClass o => HTMLBRElementClass o +toHTMLBRElement :: HTMLBRElementClass o => o -> HTMLBRElement +toHTMLBRElement = unsafeCastGObject . toGObject + +instance HTMLBRElementClass HTMLBRElement +instance HTMLElementClass HTMLBRElement +instance ElementClass HTMLBRElement +instance NodeClass HTMLBRElement +instance EventTargetClass HTMLBRElement +instance GObjectClass HTMLBRElement where + toGObject = GObject . castForeignPtr . unHTMLBRElement + unsafeCastGObject = HTMLBRElement . castForeignPtr . unGObject + +castToHTMLBRElement :: GObjectClass obj => obj -> HTMLBRElement +castToHTMLBRElement = castTo gTypeHTMLBRElement "HTMLBRElement" + +gTypeHTMLBRElement :: GType +gTypeHTMLBRElement = + {# call fun unsafe webkit_dom_htmlbr_element_get_type #} + +-- ************************************************************ HTMLBaseElement + +{#pointer *WebKitDOMHTMLBaseElement as HTMLBaseElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLBaseElement = (HTMLBaseElement, objectUnrefFromMainloop) +unHTMLBaseElement (HTMLBaseElement o) = o + +class HTMLElementClass o => HTMLBaseElementClass o +toHTMLBaseElement :: HTMLBaseElementClass o => o -> HTMLBaseElement +toHTMLBaseElement = unsafeCastGObject . toGObject + +instance HTMLBaseElementClass HTMLBaseElement +instance HTMLElementClass HTMLBaseElement +instance ElementClass HTMLBaseElement +instance NodeClass HTMLBaseElement +instance EventTargetClass HTMLBaseElement +instance GObjectClass HTMLBaseElement where + toGObject = GObject . castForeignPtr . unHTMLBaseElement + unsafeCastGObject = HTMLBaseElement . castForeignPtr . unGObject + +castToHTMLBaseElement :: GObjectClass obj => obj -> HTMLBaseElement +castToHTMLBaseElement = castTo gTypeHTMLBaseElement "HTMLBaseElement" + +gTypeHTMLBaseElement :: GType +gTypeHTMLBaseElement = + {# call fun unsafe webkit_dom_html_base_element_get_type #} + +-- ******************************************************** HTMLBaseFontElement + +{#pointer *WebKitDOMHTMLBaseFontElement as HTMLBaseFontElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLBaseFontElement = (HTMLBaseFontElement, objectUnrefFromMainloop) +unHTMLBaseFontElement (HTMLBaseFontElement o) = o + +class HTMLElementClass o => HTMLBaseFontElementClass o +toHTMLBaseFontElement :: HTMLBaseFontElementClass o => o -> HTMLBaseFontElement +toHTMLBaseFontElement = unsafeCastGObject . toGObject + +instance HTMLBaseFontElementClass HTMLBaseFontElement +instance HTMLElementClass HTMLBaseFontElement +instance ElementClass HTMLBaseFontElement +instance NodeClass HTMLBaseFontElement +instance EventTargetClass HTMLBaseFontElement +instance GObjectClass HTMLBaseFontElement where + toGObject = GObject . castForeignPtr . unHTMLBaseFontElement + unsafeCastGObject = HTMLBaseFontElement . castForeignPtr . unGObject + +castToHTMLBaseFontElement :: GObjectClass obj => obj -> HTMLBaseFontElement +castToHTMLBaseFontElement = castTo gTypeHTMLBaseFontElement "HTMLBaseFontElement" + +gTypeHTMLBaseFontElement :: GType +gTypeHTMLBaseFontElement = + {# call fun unsafe webkit_dom_html_base_font_element_get_type #} + +-- ************************************************************ HTMLBodyElement + +{#pointer *WebKitDOMHTMLBodyElement as HTMLBodyElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLBodyElement = (HTMLBodyElement, objectUnrefFromMainloop) +unHTMLBodyElement (HTMLBodyElement o) = o + +class HTMLElementClass o => HTMLBodyElementClass o +toHTMLBodyElement :: HTMLBodyElementClass o => o -> HTMLBodyElement +toHTMLBodyElement = unsafeCastGObject . toGObject + +instance HTMLBodyElementClass HTMLBodyElement +instance HTMLElementClass HTMLBodyElement +instance ElementClass HTMLBodyElement +instance NodeClass HTMLBodyElement +instance EventTargetClass HTMLBodyElement +instance GObjectClass HTMLBodyElement where + toGObject = GObject . castForeignPtr . unHTMLBodyElement + unsafeCastGObject = HTMLBodyElement . castForeignPtr . unGObject + +castToHTMLBodyElement :: GObjectClass obj => obj -> HTMLBodyElement +castToHTMLBodyElement = castTo gTypeHTMLBodyElement "HTMLBodyElement" + +gTypeHTMLBodyElement :: GType +gTypeHTMLBodyElement = + {# call fun unsafe webkit_dom_html_body_element_get_type #} + +-- ********************************************************** HTMLButtonElement + +{#pointer *WebKitDOMHTMLButtonElement as HTMLButtonElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLButtonElement = (HTMLButtonElement, objectUnrefFromMainloop) +unHTMLButtonElement (HTMLButtonElement o) = o + +class HTMLElementClass o => HTMLButtonElementClass o +toHTMLButtonElement :: HTMLButtonElementClass o => o -> HTMLButtonElement +toHTMLButtonElement = unsafeCastGObject . toGObject + +instance HTMLButtonElementClass HTMLButtonElement +instance HTMLElementClass HTMLButtonElement +instance ElementClass HTMLButtonElement +instance NodeClass HTMLButtonElement +instance EventTargetClass HTMLButtonElement +instance GObjectClass HTMLButtonElement where + toGObject = GObject . castForeignPtr . unHTMLButtonElement + unsafeCastGObject = HTMLButtonElement . castForeignPtr . unGObject + +castToHTMLButtonElement :: GObjectClass obj => obj -> HTMLButtonElement +castToHTMLButtonElement = castTo gTypeHTMLButtonElement "HTMLButtonElement" + +gTypeHTMLButtonElement :: GType +gTypeHTMLButtonElement = + {# call fun unsafe webkit_dom_html_button_element_get_type #} + +-- ********************************************************** HTMLCanvasElement + +{#pointer *WebKitDOMHTMLCanvasElement as HTMLCanvasElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLCanvasElement = (HTMLCanvasElement, objectUnrefFromMainloop) +unHTMLCanvasElement (HTMLCanvasElement o) = o + +class HTMLElementClass o => HTMLCanvasElementClass o +toHTMLCanvasElement :: HTMLCanvasElementClass o => o -> HTMLCanvasElement +toHTMLCanvasElement = unsafeCastGObject . toGObject + +instance HTMLCanvasElementClass HTMLCanvasElement +instance HTMLElementClass HTMLCanvasElement +instance ElementClass HTMLCanvasElement +instance NodeClass HTMLCanvasElement +instance EventTargetClass HTMLCanvasElement +instance GObjectClass HTMLCanvasElement where + toGObject = GObject . castForeignPtr . unHTMLCanvasElement + unsafeCastGObject = HTMLCanvasElement . castForeignPtr . unGObject + +castToHTMLCanvasElement :: GObjectClass obj => obj -> HTMLCanvasElement +castToHTMLCanvasElement = castTo gTypeHTMLCanvasElement "HTMLCanvasElement" + +gTypeHTMLCanvasElement :: GType +gTypeHTMLCanvasElement = + {# call fun unsafe webkit_dom_html_canvas_element_get_type #} + +-- *********************************************************** HTMLDListElement + +{#pointer *WebKitDOMHTMLDListElement as HTMLDListElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLDListElement = (HTMLDListElement, objectUnrefFromMainloop) +unHTMLDListElement (HTMLDListElement o) = o + +class HTMLElementClass o => HTMLDListElementClass o +toHTMLDListElement :: HTMLDListElementClass o => o -> HTMLDListElement +toHTMLDListElement = unsafeCastGObject . toGObject + +instance HTMLDListElementClass HTMLDListElement +instance HTMLElementClass HTMLDListElement +instance ElementClass HTMLDListElement +instance NodeClass HTMLDListElement +instance EventTargetClass HTMLDListElement +instance GObjectClass HTMLDListElement where + toGObject = GObject . castForeignPtr . unHTMLDListElement + unsafeCastGObject = HTMLDListElement . castForeignPtr . unGObject + +castToHTMLDListElement :: GObjectClass obj => obj -> HTMLDListElement +castToHTMLDListElement = castTo gTypeHTMLDListElement "HTMLDListElement" + +gTypeHTMLDListElement :: GType +gTypeHTMLDListElement = + {# call fun unsafe webkit_dom_htmld_list_element_get_type #} + +-- ********************************************************* HTMLDetailsElement + +{#pointer *WebKitDOMHTMLDetailsElement as HTMLDetailsElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLDetailsElement = (HTMLDetailsElement, objectUnrefFromMainloop) +unHTMLDetailsElement (HTMLDetailsElement o) = o + +class HTMLElementClass o => HTMLDetailsElementClass o +toHTMLDetailsElement :: HTMLDetailsElementClass o => o -> HTMLDetailsElement +toHTMLDetailsElement = unsafeCastGObject . toGObject + +instance HTMLDetailsElementClass HTMLDetailsElement +instance HTMLElementClass HTMLDetailsElement +instance ElementClass HTMLDetailsElement +instance NodeClass HTMLDetailsElement +instance EventTargetClass HTMLDetailsElement +instance GObjectClass HTMLDetailsElement where + toGObject = GObject . castForeignPtr . unHTMLDetailsElement + unsafeCastGObject = HTMLDetailsElement . castForeignPtr . unGObject + +castToHTMLDetailsElement :: GObjectClass obj => obj -> HTMLDetailsElement +castToHTMLDetailsElement = castTo gTypeHTMLDetailsElement "HTMLDetailsElement" + +gTypeHTMLDetailsElement :: GType +gTypeHTMLDetailsElement = + {# call fun unsafe webkit_dom_html_details_element_get_type #} + +-- ******************************************************* HTMLDirectoryElement + +{#pointer *WebKitDOMHTMLDirectoryElement as HTMLDirectoryElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLDirectoryElement = (HTMLDirectoryElement, objectUnrefFromMainloop) +unHTMLDirectoryElement (HTMLDirectoryElement o) = o + +class HTMLElementClass o => HTMLDirectoryElementClass o +toHTMLDirectoryElement :: HTMLDirectoryElementClass o => o -> HTMLDirectoryElement +toHTMLDirectoryElement = unsafeCastGObject . toGObject + +instance HTMLDirectoryElementClass HTMLDirectoryElement +instance HTMLElementClass HTMLDirectoryElement +instance ElementClass HTMLDirectoryElement +instance NodeClass HTMLDirectoryElement +instance EventTargetClass HTMLDirectoryElement +instance GObjectClass HTMLDirectoryElement where + toGObject = GObject . castForeignPtr . unHTMLDirectoryElement + unsafeCastGObject = HTMLDirectoryElement . castForeignPtr . unGObject + +castToHTMLDirectoryElement :: GObjectClass obj => obj -> HTMLDirectoryElement +castToHTMLDirectoryElement = castTo gTypeHTMLDirectoryElement "HTMLDirectoryElement" + +gTypeHTMLDirectoryElement :: GType +gTypeHTMLDirectoryElement = + {# call fun unsafe webkit_dom_html_directory_element_get_type #} + +-- ************************************************************* HTMLDivElement + +{#pointer *WebKitDOMHTMLDivElement as HTMLDivElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLDivElement = (HTMLDivElement, objectUnrefFromMainloop) +unHTMLDivElement (HTMLDivElement o) = o + +class HTMLElementClass o => HTMLDivElementClass o +toHTMLDivElement :: HTMLDivElementClass o => o -> HTMLDivElement +toHTMLDivElement = unsafeCastGObject . toGObject + +instance HTMLDivElementClass HTMLDivElement +instance HTMLElementClass HTMLDivElement +instance ElementClass HTMLDivElement +instance NodeClass HTMLDivElement +instance EventTargetClass HTMLDivElement +instance GObjectClass HTMLDivElement where + toGObject = GObject . castForeignPtr . unHTMLDivElement + unsafeCastGObject = HTMLDivElement . castForeignPtr . unGObject + +castToHTMLDivElement :: GObjectClass obj => obj -> HTMLDivElement +castToHTMLDivElement = castTo gTypeHTMLDivElement "HTMLDivElement" + +gTypeHTMLDivElement :: GType +gTypeHTMLDivElement = + {# call fun unsafe webkit_dom_html_div_element_get_type #} + +-- *********************************************************** HTMLEmbedElement + +{#pointer *WebKitDOMHTMLEmbedElement as HTMLEmbedElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLEmbedElement = (HTMLEmbedElement, objectUnrefFromMainloop) +unHTMLEmbedElement (HTMLEmbedElement o) = o + +class HTMLElementClass o => HTMLEmbedElementClass o +toHTMLEmbedElement :: HTMLEmbedElementClass o => o -> HTMLEmbedElement +toHTMLEmbedElement = unsafeCastGObject . toGObject + +instance HTMLEmbedElementClass HTMLEmbedElement +instance HTMLElementClass HTMLEmbedElement +instance ElementClass HTMLEmbedElement +instance NodeClass HTMLEmbedElement +instance EventTargetClass HTMLEmbedElement +instance GObjectClass HTMLEmbedElement where + toGObject = GObject . castForeignPtr . unHTMLEmbedElement + unsafeCastGObject = HTMLEmbedElement . castForeignPtr . unGObject + +castToHTMLEmbedElement :: GObjectClass obj => obj -> HTMLEmbedElement +castToHTMLEmbedElement = castTo gTypeHTMLEmbedElement "HTMLEmbedElement" + +gTypeHTMLEmbedElement :: GType +gTypeHTMLEmbedElement = + {# call fun unsafe webkit_dom_html_embed_element_get_type #} + +-- ******************************************************** HTMLFieldSetElement + +{#pointer *WebKitDOMHTMLFieldSetElement as HTMLFieldSetElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLFieldSetElement = (HTMLFieldSetElement, objectUnrefFromMainloop) +unHTMLFieldSetElement (HTMLFieldSetElement o) = o + +class HTMLElementClass o => HTMLFieldSetElementClass o +toHTMLFieldSetElement :: HTMLFieldSetElementClass o => o -> HTMLFieldSetElement +toHTMLFieldSetElement = unsafeCastGObject . toGObject + +instance HTMLFieldSetElementClass HTMLFieldSetElement +instance HTMLElementClass HTMLFieldSetElement +instance ElementClass HTMLFieldSetElement +instance NodeClass HTMLFieldSetElement +instance EventTargetClass HTMLFieldSetElement +instance GObjectClass HTMLFieldSetElement where + toGObject = GObject . castForeignPtr . unHTMLFieldSetElement + unsafeCastGObject = HTMLFieldSetElement . castForeignPtr . unGObject + +castToHTMLFieldSetElement :: GObjectClass obj => obj -> HTMLFieldSetElement +castToHTMLFieldSetElement = castTo gTypeHTMLFieldSetElement "HTMLFieldSetElement" + +gTypeHTMLFieldSetElement :: GType +gTypeHTMLFieldSetElement = + {# call fun unsafe webkit_dom_html_field_set_element_get_type #} + +-- ************************************************************ HTMLFontElement + +{#pointer *WebKitDOMHTMLFontElement as HTMLFontElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLFontElement = (HTMLFontElement, objectUnrefFromMainloop) +unHTMLFontElement (HTMLFontElement o) = o + +class HTMLElementClass o => HTMLFontElementClass o +toHTMLFontElement :: HTMLFontElementClass o => o -> HTMLFontElement +toHTMLFontElement = unsafeCastGObject . toGObject + +instance HTMLFontElementClass HTMLFontElement +instance HTMLElementClass HTMLFontElement +instance ElementClass HTMLFontElement +instance NodeClass HTMLFontElement +instance EventTargetClass HTMLFontElement +instance GObjectClass HTMLFontElement where + toGObject = GObject . castForeignPtr . unHTMLFontElement + unsafeCastGObject = HTMLFontElement . castForeignPtr . unGObject + +castToHTMLFontElement :: GObjectClass obj => obj -> HTMLFontElement +castToHTMLFontElement = castTo gTypeHTMLFontElement "HTMLFontElement" + +gTypeHTMLFontElement :: GType +gTypeHTMLFontElement = + {# call fun unsafe webkit_dom_html_font_element_get_type #} + +-- ************************************************************ HTMLFormElement + +{#pointer *WebKitDOMHTMLFormElement as HTMLFormElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLFormElement = (HTMLFormElement, objectUnrefFromMainloop) +unHTMLFormElement (HTMLFormElement o) = o + +class HTMLElementClass o => HTMLFormElementClass o +toHTMLFormElement :: HTMLFormElementClass o => o -> HTMLFormElement +toHTMLFormElement = unsafeCastGObject . toGObject + +instance HTMLFormElementClass HTMLFormElement +instance HTMLElementClass HTMLFormElement +instance ElementClass HTMLFormElement +instance NodeClass HTMLFormElement +instance EventTargetClass HTMLFormElement +instance GObjectClass HTMLFormElement where + toGObject = GObject . castForeignPtr . unHTMLFormElement + unsafeCastGObject = HTMLFormElement . castForeignPtr . unGObject + +castToHTMLFormElement :: GObjectClass obj => obj -> HTMLFormElement +castToHTMLFormElement = castTo gTypeHTMLFormElement "HTMLFormElement" + +gTypeHTMLFormElement :: GType +gTypeHTMLFormElement = + {# call fun unsafe webkit_dom_html_form_element_get_type #} + +-- *********************************************************** HTMLFrameElement + +{#pointer *WebKitDOMHTMLFrameElement as HTMLFrameElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLFrameElement = (HTMLFrameElement, objectUnrefFromMainloop) +unHTMLFrameElement (HTMLFrameElement o) = o + +class HTMLElementClass o => HTMLFrameElementClass o +toHTMLFrameElement :: HTMLFrameElementClass o => o -> HTMLFrameElement +toHTMLFrameElement = unsafeCastGObject . toGObject + +instance HTMLFrameElementClass HTMLFrameElement +instance HTMLElementClass HTMLFrameElement +instance ElementClass HTMLFrameElement +instance NodeClass HTMLFrameElement +instance EventTargetClass HTMLFrameElement +instance GObjectClass HTMLFrameElement where + toGObject = GObject . castForeignPtr . unHTMLFrameElement + unsafeCastGObject = HTMLFrameElement . castForeignPtr . unGObject + +castToHTMLFrameElement :: GObjectClass obj => obj -> HTMLFrameElement +castToHTMLFrameElement = castTo gTypeHTMLFrameElement "HTMLFrameElement" + +gTypeHTMLFrameElement :: GType +gTypeHTMLFrameElement = + {# call fun unsafe webkit_dom_html_frame_element_get_type #} + +-- ******************************************************** HTMLFrameSetElement + +{#pointer *WebKitDOMHTMLFrameSetElement as HTMLFrameSetElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLFrameSetElement = (HTMLFrameSetElement, objectUnrefFromMainloop) +unHTMLFrameSetElement (HTMLFrameSetElement o) = o + +class HTMLElementClass o => HTMLFrameSetElementClass o +toHTMLFrameSetElement :: HTMLFrameSetElementClass o => o -> HTMLFrameSetElement +toHTMLFrameSetElement = unsafeCastGObject . toGObject + +instance HTMLFrameSetElementClass HTMLFrameSetElement +instance HTMLElementClass HTMLFrameSetElement +instance ElementClass HTMLFrameSetElement +instance NodeClass HTMLFrameSetElement +instance EventTargetClass HTMLFrameSetElement +instance GObjectClass HTMLFrameSetElement where + toGObject = GObject . castForeignPtr . unHTMLFrameSetElement + unsafeCastGObject = HTMLFrameSetElement . castForeignPtr . unGObject + +castToHTMLFrameSetElement :: GObjectClass obj => obj -> HTMLFrameSetElement +castToHTMLFrameSetElement = castTo gTypeHTMLFrameSetElement "HTMLFrameSetElement" + +gTypeHTMLFrameSetElement :: GType +gTypeHTMLFrameSetElement = + {# call fun unsafe webkit_dom_html_frame_set_element_get_type #} + +-- ************************************************************** HTMLHRElement + +{#pointer *WebKitDOMHTMLHRElement as HTMLHRElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLHRElement = (HTMLHRElement, objectUnrefFromMainloop) +unHTMLHRElement (HTMLHRElement o) = o + +class HTMLElementClass o => HTMLHRElementClass o +toHTMLHRElement :: HTMLHRElementClass o => o -> HTMLHRElement +toHTMLHRElement = unsafeCastGObject . toGObject + +instance HTMLHRElementClass HTMLHRElement +instance HTMLElementClass HTMLHRElement +instance ElementClass HTMLHRElement +instance NodeClass HTMLHRElement +instance EventTargetClass HTMLHRElement +instance GObjectClass HTMLHRElement where + toGObject = GObject . castForeignPtr . unHTMLHRElement + unsafeCastGObject = HTMLHRElement . castForeignPtr . unGObject + +castToHTMLHRElement :: GObjectClass obj => obj -> HTMLHRElement +castToHTMLHRElement = castTo gTypeHTMLHRElement "HTMLHRElement" + +gTypeHTMLHRElement :: GType +gTypeHTMLHRElement = + {# call fun unsafe webkit_dom_htmlhr_element_get_type #} + +-- ************************************************************ HTMLHeadElement + +{#pointer *WebKitDOMHTMLHeadElement as HTMLHeadElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLHeadElement = (HTMLHeadElement, objectUnrefFromMainloop) +unHTMLHeadElement (HTMLHeadElement o) = o + +class HTMLElementClass o => HTMLHeadElementClass o +toHTMLHeadElement :: HTMLHeadElementClass o => o -> HTMLHeadElement +toHTMLHeadElement = unsafeCastGObject . toGObject + +instance HTMLHeadElementClass HTMLHeadElement +instance HTMLElementClass HTMLHeadElement +instance ElementClass HTMLHeadElement +instance NodeClass HTMLHeadElement +instance EventTargetClass HTMLHeadElement +instance GObjectClass HTMLHeadElement where + toGObject = GObject . castForeignPtr . unHTMLHeadElement + unsafeCastGObject = HTMLHeadElement . castForeignPtr . unGObject + +castToHTMLHeadElement :: GObjectClass obj => obj -> HTMLHeadElement +castToHTMLHeadElement = castTo gTypeHTMLHeadElement "HTMLHeadElement" + +gTypeHTMLHeadElement :: GType +gTypeHTMLHeadElement = + {# call fun unsafe webkit_dom_html_head_element_get_type #} + +-- ********************************************************* HTMLHeadingElement + +{#pointer *WebKitDOMHTMLHeadingElement as HTMLHeadingElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLHeadingElement = (HTMLHeadingElement, objectUnrefFromMainloop) +unHTMLHeadingElement (HTMLHeadingElement o) = o + +class HTMLElementClass o => HTMLHeadingElementClass o +toHTMLHeadingElement :: HTMLHeadingElementClass o => o -> HTMLHeadingElement +toHTMLHeadingElement = unsafeCastGObject . toGObject + +instance HTMLHeadingElementClass HTMLHeadingElement +instance HTMLElementClass HTMLHeadingElement +instance ElementClass HTMLHeadingElement +instance NodeClass HTMLHeadingElement +instance EventTargetClass HTMLHeadingElement +instance GObjectClass HTMLHeadingElement where + toGObject = GObject . castForeignPtr . unHTMLHeadingElement + unsafeCastGObject = HTMLHeadingElement . castForeignPtr . unGObject + +castToHTMLHeadingElement :: GObjectClass obj => obj -> HTMLHeadingElement +castToHTMLHeadingElement = castTo gTypeHTMLHeadingElement "HTMLHeadingElement" + +gTypeHTMLHeadingElement :: GType +gTypeHTMLHeadingElement = + {# call fun unsafe webkit_dom_html_heading_element_get_type #} + +-- ************************************************************ HTMLHtmlElement + +{#pointer *WebKitDOMHTMLHtmlElement as HTMLHtmlElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLHtmlElement = (HTMLHtmlElement, objectUnrefFromMainloop) +unHTMLHtmlElement (HTMLHtmlElement o) = o + +class HTMLElementClass o => HTMLHtmlElementClass o +toHTMLHtmlElement :: HTMLHtmlElementClass o => o -> HTMLHtmlElement +toHTMLHtmlElement = unsafeCastGObject . toGObject + +instance HTMLHtmlElementClass HTMLHtmlElement +instance HTMLElementClass HTMLHtmlElement +instance ElementClass HTMLHtmlElement +instance NodeClass HTMLHtmlElement +instance EventTargetClass HTMLHtmlElement +instance GObjectClass HTMLHtmlElement where + toGObject = GObject . castForeignPtr . unHTMLHtmlElement + unsafeCastGObject = HTMLHtmlElement . castForeignPtr . unGObject + +castToHTMLHtmlElement :: GObjectClass obj => obj -> HTMLHtmlElement +castToHTMLHtmlElement = castTo gTypeHTMLHtmlElement "HTMLHtmlElement" + +gTypeHTMLHtmlElement :: GType +gTypeHTMLHtmlElement = + {# call fun unsafe webkit_dom_html_html_element_get_type #} + +-- ********************************************************** HTMLIFrameElement + +{#pointer *WebKitDOMHTMLIFrameElement as HTMLIFrameElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLIFrameElement = (HTMLIFrameElement, objectUnrefFromMainloop) +unHTMLIFrameElement (HTMLIFrameElement o) = o + +class HTMLElementClass o => HTMLIFrameElementClass o +toHTMLIFrameElement :: HTMLIFrameElementClass o => o -> HTMLIFrameElement +toHTMLIFrameElement = unsafeCastGObject . toGObject + +instance HTMLIFrameElementClass HTMLIFrameElement +instance HTMLElementClass HTMLIFrameElement +instance ElementClass HTMLIFrameElement +instance NodeClass HTMLIFrameElement +instance EventTargetClass HTMLIFrameElement +instance GObjectClass HTMLIFrameElement where + toGObject = GObject . castForeignPtr . unHTMLIFrameElement + unsafeCastGObject = HTMLIFrameElement . castForeignPtr . unGObject + +castToHTMLIFrameElement :: GObjectClass obj => obj -> HTMLIFrameElement +castToHTMLIFrameElement = castTo gTypeHTMLIFrameElement "HTMLIFrameElement" + +gTypeHTMLIFrameElement :: GType +gTypeHTMLIFrameElement = + {# call fun unsafe webkit_dom_html_iframe_element_get_type #} + +-- *********************************************************** HTMLImageElement + +{#pointer *WebKitDOMHTMLImageElement as HTMLImageElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLImageElement = (HTMLImageElement, objectUnrefFromMainloop) +unHTMLImageElement (HTMLImageElement o) = o + +class HTMLElementClass o => HTMLImageElementClass o +toHTMLImageElement :: HTMLImageElementClass o => o -> HTMLImageElement +toHTMLImageElement = unsafeCastGObject . toGObject + +instance HTMLImageElementClass HTMLImageElement +instance HTMLElementClass HTMLImageElement +instance ElementClass HTMLImageElement +instance NodeClass HTMLImageElement +instance EventTargetClass HTMLImageElement +instance GObjectClass HTMLImageElement where + toGObject = GObject . castForeignPtr . unHTMLImageElement + unsafeCastGObject = HTMLImageElement . castForeignPtr . unGObject + +castToHTMLImageElement :: GObjectClass obj => obj -> HTMLImageElement +castToHTMLImageElement = castTo gTypeHTMLImageElement "HTMLImageElement" + +gTypeHTMLImageElement :: GType +gTypeHTMLImageElement = + {# call fun unsafe webkit_dom_html_image_element_get_type #} + +-- *********************************************************** HTMLInputElement + +{#pointer *WebKitDOMHTMLInputElement as HTMLInputElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLInputElement = (HTMLInputElement, objectUnrefFromMainloop) +unHTMLInputElement (HTMLInputElement o) = o + +class HTMLElementClass o => HTMLInputElementClass o +toHTMLInputElement :: HTMLInputElementClass o => o -> HTMLInputElement +toHTMLInputElement = unsafeCastGObject . toGObject + +instance HTMLInputElementClass HTMLInputElement +instance HTMLElementClass HTMLInputElement +instance ElementClass HTMLInputElement +instance NodeClass HTMLInputElement +instance EventTargetClass HTMLInputElement +instance GObjectClass HTMLInputElement where + toGObject = GObject . castForeignPtr . unHTMLInputElement + unsafeCastGObject = HTMLInputElement . castForeignPtr . unGObject + +castToHTMLInputElement :: GObjectClass obj => obj -> HTMLInputElement +castToHTMLInputElement = castTo gTypeHTMLInputElement "HTMLInputElement" + +gTypeHTMLInputElement :: GType +gTypeHTMLInputElement = + {# call fun unsafe webkit_dom_html_input_element_get_type #} + +-- ********************************************************** HTMLKeygenElement + +{#pointer *WebKitDOMHTMLKeygenElement as HTMLKeygenElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLKeygenElement = (HTMLKeygenElement, objectUnrefFromMainloop) +unHTMLKeygenElement (HTMLKeygenElement o) = o + +class HTMLElementClass o => HTMLKeygenElementClass o +toHTMLKeygenElement :: HTMLKeygenElementClass o => o -> HTMLKeygenElement +toHTMLKeygenElement = unsafeCastGObject . toGObject + +instance HTMLKeygenElementClass HTMLKeygenElement +instance HTMLElementClass HTMLKeygenElement +instance ElementClass HTMLKeygenElement +instance NodeClass HTMLKeygenElement +instance EventTargetClass HTMLKeygenElement +instance GObjectClass HTMLKeygenElement where + toGObject = GObject . castForeignPtr . unHTMLKeygenElement + unsafeCastGObject = HTMLKeygenElement . castForeignPtr . unGObject + +castToHTMLKeygenElement :: GObjectClass obj => obj -> HTMLKeygenElement +castToHTMLKeygenElement = castTo gTypeHTMLKeygenElement "HTMLKeygenElement" + +gTypeHTMLKeygenElement :: GType +gTypeHTMLKeygenElement = + {# call fun unsafe webkit_dom_html_keygen_element_get_type #} + +-- ************************************************************** HTMLLIElement + +{#pointer *WebKitDOMHTMLLIElement as HTMLLIElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLLIElement = (HTMLLIElement, objectUnrefFromMainloop) +unHTMLLIElement (HTMLLIElement o) = o + +class HTMLElementClass o => HTMLLIElementClass o +toHTMLLIElement :: HTMLLIElementClass o => o -> HTMLLIElement +toHTMLLIElement = unsafeCastGObject . toGObject + +instance HTMLLIElementClass HTMLLIElement +instance HTMLElementClass HTMLLIElement +instance ElementClass HTMLLIElement +instance NodeClass HTMLLIElement +instance EventTargetClass HTMLLIElement +instance GObjectClass HTMLLIElement where + toGObject = GObject . castForeignPtr . unHTMLLIElement + unsafeCastGObject = HTMLLIElement . castForeignPtr . unGObject + +castToHTMLLIElement :: GObjectClass obj => obj -> HTMLLIElement +castToHTMLLIElement = castTo gTypeHTMLLIElement "HTMLLIElement" + +gTypeHTMLLIElement :: GType +gTypeHTMLLIElement = + {# call fun unsafe webkit_dom_htmlli_element_get_type #} + +-- *********************************************************** HTMLLabelElement + +{#pointer *WebKitDOMHTMLLabelElement as HTMLLabelElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLLabelElement = (HTMLLabelElement, objectUnrefFromMainloop) +unHTMLLabelElement (HTMLLabelElement o) = o + +class HTMLElementClass o => HTMLLabelElementClass o +toHTMLLabelElement :: HTMLLabelElementClass o => o -> HTMLLabelElement +toHTMLLabelElement = unsafeCastGObject . toGObject + +instance HTMLLabelElementClass HTMLLabelElement +instance HTMLElementClass HTMLLabelElement +instance ElementClass HTMLLabelElement +instance NodeClass HTMLLabelElement +instance EventTargetClass HTMLLabelElement +instance GObjectClass HTMLLabelElement where + toGObject = GObject . castForeignPtr . unHTMLLabelElement + unsafeCastGObject = HTMLLabelElement . castForeignPtr . unGObject + +castToHTMLLabelElement :: GObjectClass obj => obj -> HTMLLabelElement +castToHTMLLabelElement = castTo gTypeHTMLLabelElement "HTMLLabelElement" + +gTypeHTMLLabelElement :: GType +gTypeHTMLLabelElement = + {# call fun unsafe webkit_dom_html_label_element_get_type #} + +-- ********************************************************** HTMLLegendElement + +{#pointer *WebKitDOMHTMLLegendElement as HTMLLegendElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLLegendElement = (HTMLLegendElement, objectUnrefFromMainloop) +unHTMLLegendElement (HTMLLegendElement o) = o + +class HTMLElementClass o => HTMLLegendElementClass o +toHTMLLegendElement :: HTMLLegendElementClass o => o -> HTMLLegendElement +toHTMLLegendElement = unsafeCastGObject . toGObject + +instance HTMLLegendElementClass HTMLLegendElement +instance HTMLElementClass HTMLLegendElement +instance ElementClass HTMLLegendElement +instance NodeClass HTMLLegendElement +instance EventTargetClass HTMLLegendElement +instance GObjectClass HTMLLegendElement where + toGObject = GObject . castForeignPtr . unHTMLLegendElement + unsafeCastGObject = HTMLLegendElement . castForeignPtr . unGObject + +castToHTMLLegendElement :: GObjectClass obj => obj -> HTMLLegendElement +castToHTMLLegendElement = castTo gTypeHTMLLegendElement "HTMLLegendElement" + +gTypeHTMLLegendElement :: GType +gTypeHTMLLegendElement = + {# call fun unsafe webkit_dom_html_legend_element_get_type #} + +-- ************************************************************ HTMLLinkElement + +{#pointer *WebKitDOMHTMLLinkElement as HTMLLinkElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLLinkElement = (HTMLLinkElement, objectUnrefFromMainloop) +unHTMLLinkElement (HTMLLinkElement o) = o + +class HTMLElementClass o => HTMLLinkElementClass o +toHTMLLinkElement :: HTMLLinkElementClass o => o -> HTMLLinkElement +toHTMLLinkElement = unsafeCastGObject . toGObject + +instance HTMLLinkElementClass HTMLLinkElement +instance HTMLElementClass HTMLLinkElement +instance ElementClass HTMLLinkElement +instance NodeClass HTMLLinkElement +instance EventTargetClass HTMLLinkElement +instance GObjectClass HTMLLinkElement where + toGObject = GObject . castForeignPtr . unHTMLLinkElement + unsafeCastGObject = HTMLLinkElement . castForeignPtr . unGObject + +castToHTMLLinkElement :: GObjectClass obj => obj -> HTMLLinkElement +castToHTMLLinkElement = castTo gTypeHTMLLinkElement "HTMLLinkElement" + +gTypeHTMLLinkElement :: GType +gTypeHTMLLinkElement = + {# call fun unsafe webkit_dom_html_link_element_get_type #} + +-- ************************************************************* HTMLMapElement + +{#pointer *WebKitDOMHTMLMapElement as HTMLMapElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLMapElement = (HTMLMapElement, objectUnrefFromMainloop) +unHTMLMapElement (HTMLMapElement o) = o + +class HTMLElementClass o => HTMLMapElementClass o +toHTMLMapElement :: HTMLMapElementClass o => o -> HTMLMapElement +toHTMLMapElement = unsafeCastGObject . toGObject + +instance HTMLMapElementClass HTMLMapElement +instance HTMLElementClass HTMLMapElement +instance ElementClass HTMLMapElement +instance NodeClass HTMLMapElement +instance EventTargetClass HTMLMapElement +instance GObjectClass HTMLMapElement where + toGObject = GObject . castForeignPtr . unHTMLMapElement + unsafeCastGObject = HTMLMapElement . castForeignPtr . unGObject + +castToHTMLMapElement :: GObjectClass obj => obj -> HTMLMapElement +castToHTMLMapElement = castTo gTypeHTMLMapElement "HTMLMapElement" + +gTypeHTMLMapElement :: GType +gTypeHTMLMapElement = + {# call fun unsafe webkit_dom_html_map_element_get_type #} + +-- ********************************************************* HTMLMarqueeElement + +{#pointer *WebKitDOMHTMLMarqueeElement as HTMLMarqueeElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLMarqueeElement = (HTMLMarqueeElement, objectUnrefFromMainloop) +unHTMLMarqueeElement (HTMLMarqueeElement o) = o + +class HTMLElementClass o => HTMLMarqueeElementClass o +toHTMLMarqueeElement :: HTMLMarqueeElementClass o => o -> HTMLMarqueeElement +toHTMLMarqueeElement = unsafeCastGObject . toGObject + +instance HTMLMarqueeElementClass HTMLMarqueeElement +instance HTMLElementClass HTMLMarqueeElement +instance ElementClass HTMLMarqueeElement +instance NodeClass HTMLMarqueeElement +instance EventTargetClass HTMLMarqueeElement +instance GObjectClass HTMLMarqueeElement where + toGObject = GObject . castForeignPtr . unHTMLMarqueeElement + unsafeCastGObject = HTMLMarqueeElement . castForeignPtr . unGObject + +castToHTMLMarqueeElement :: GObjectClass obj => obj -> HTMLMarqueeElement +castToHTMLMarqueeElement = castTo gTypeHTMLMarqueeElement "HTMLMarqueeElement" + +gTypeHTMLMarqueeElement :: GType +gTypeHTMLMarqueeElement = + {# call fun unsafe webkit_dom_html_marquee_element_get_type #} + +-- ************************************************************ HTMLMenuElement + +{#pointer *WebKitDOMHTMLMenuElement as HTMLMenuElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLMenuElement = (HTMLMenuElement, objectUnrefFromMainloop) +unHTMLMenuElement (HTMLMenuElement o) = o + +class HTMLElementClass o => HTMLMenuElementClass o +toHTMLMenuElement :: HTMLMenuElementClass o => o -> HTMLMenuElement +toHTMLMenuElement = unsafeCastGObject . toGObject + +instance HTMLMenuElementClass HTMLMenuElement +instance HTMLElementClass HTMLMenuElement +instance ElementClass HTMLMenuElement +instance NodeClass HTMLMenuElement +instance EventTargetClass HTMLMenuElement +instance GObjectClass HTMLMenuElement where + toGObject = GObject . castForeignPtr . unHTMLMenuElement + unsafeCastGObject = HTMLMenuElement . castForeignPtr . unGObject + +castToHTMLMenuElement :: GObjectClass obj => obj -> HTMLMenuElement +castToHTMLMenuElement = castTo gTypeHTMLMenuElement "HTMLMenuElement" + +gTypeHTMLMenuElement :: GType +gTypeHTMLMenuElement = + {# call fun unsafe webkit_dom_html_menu_element_get_type #} + +-- ************************************************************ HTMLMetaElement + +{#pointer *WebKitDOMHTMLMetaElement as HTMLMetaElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLMetaElement = (HTMLMetaElement, objectUnrefFromMainloop) +unHTMLMetaElement (HTMLMetaElement o) = o + +class HTMLElementClass o => HTMLMetaElementClass o +toHTMLMetaElement :: HTMLMetaElementClass o => o -> HTMLMetaElement +toHTMLMetaElement = unsafeCastGObject . toGObject + +instance HTMLMetaElementClass HTMLMetaElement +instance HTMLElementClass HTMLMetaElement +instance ElementClass HTMLMetaElement +instance NodeClass HTMLMetaElement +instance EventTargetClass HTMLMetaElement +instance GObjectClass HTMLMetaElement where + toGObject = GObject . castForeignPtr . unHTMLMetaElement + unsafeCastGObject = HTMLMetaElement . castForeignPtr . unGObject + +castToHTMLMetaElement :: GObjectClass obj => obj -> HTMLMetaElement +castToHTMLMetaElement = castTo gTypeHTMLMetaElement "HTMLMetaElement" + +gTypeHTMLMetaElement :: GType +gTypeHTMLMetaElement = + {# call fun unsafe webkit_dom_html_meta_element_get_type #} + +-- ************************************************************* HTMLModElement + +{#pointer *WebKitDOMHTMLModElement as HTMLModElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLModElement = (HTMLModElement, objectUnrefFromMainloop) +unHTMLModElement (HTMLModElement o) = o + +class HTMLElementClass o => HTMLModElementClass o +toHTMLModElement :: HTMLModElementClass o => o -> HTMLModElement +toHTMLModElement = unsafeCastGObject . toGObject + +instance HTMLModElementClass HTMLModElement +instance HTMLElementClass HTMLModElement +instance ElementClass HTMLModElement +instance NodeClass HTMLModElement +instance EventTargetClass HTMLModElement +instance GObjectClass HTMLModElement where + toGObject = GObject . castForeignPtr . unHTMLModElement + unsafeCastGObject = HTMLModElement . castForeignPtr . unGObject + +castToHTMLModElement :: GObjectClass obj => obj -> HTMLModElement +castToHTMLModElement = castTo gTypeHTMLModElement "HTMLModElement" + +gTypeHTMLModElement :: GType +gTypeHTMLModElement = + {# call fun unsafe webkit_dom_html_mod_element_get_type #} + +-- *********************************************************** HTMLOListElement + +{#pointer *WebKitDOMHTMLOListElement as HTMLOListElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLOListElement = (HTMLOListElement, objectUnrefFromMainloop) +unHTMLOListElement (HTMLOListElement o) = o + +class HTMLElementClass o => HTMLOListElementClass o +toHTMLOListElement :: HTMLOListElementClass o => o -> HTMLOListElement +toHTMLOListElement = unsafeCastGObject . toGObject + +instance HTMLOListElementClass HTMLOListElement +instance HTMLElementClass HTMLOListElement +instance ElementClass HTMLOListElement +instance NodeClass HTMLOListElement +instance EventTargetClass HTMLOListElement +instance GObjectClass HTMLOListElement where + toGObject = GObject . castForeignPtr . unHTMLOListElement + unsafeCastGObject = HTMLOListElement . castForeignPtr . unGObject + +castToHTMLOListElement :: GObjectClass obj => obj -> HTMLOListElement +castToHTMLOListElement = castTo gTypeHTMLOListElement "HTMLOListElement" + +gTypeHTMLOListElement :: GType +gTypeHTMLOListElement = + {# call fun unsafe webkit_dom_htmlo_list_element_get_type #} + +-- ********************************************************** HTMLObjectElement + +{#pointer *WebKitDOMHTMLObjectElement as HTMLObjectElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLObjectElement = (HTMLObjectElement, objectUnrefFromMainloop) +unHTMLObjectElement (HTMLObjectElement o) = o + +class HTMLElementClass o => HTMLObjectElementClass o +toHTMLObjectElement :: HTMLObjectElementClass o => o -> HTMLObjectElement +toHTMLObjectElement = unsafeCastGObject . toGObject + +instance HTMLObjectElementClass HTMLObjectElement +instance HTMLElementClass HTMLObjectElement +instance ElementClass HTMLObjectElement +instance NodeClass HTMLObjectElement +instance EventTargetClass HTMLObjectElement +instance GObjectClass HTMLObjectElement where + toGObject = GObject . castForeignPtr . unHTMLObjectElement + unsafeCastGObject = HTMLObjectElement . castForeignPtr . unGObject + +castToHTMLObjectElement :: GObjectClass obj => obj -> HTMLObjectElement +castToHTMLObjectElement = castTo gTypeHTMLObjectElement "HTMLObjectElement" + +gTypeHTMLObjectElement :: GType +gTypeHTMLObjectElement = + {# call fun unsafe webkit_dom_html_object_element_get_type #} + +-- ******************************************************** HTMLOptGroupElement + +{#pointer *WebKitDOMHTMLOptGroupElement as HTMLOptGroupElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLOptGroupElement = (HTMLOptGroupElement, objectUnrefFromMainloop) +unHTMLOptGroupElement (HTMLOptGroupElement o) = o + +class HTMLElementClass o => HTMLOptGroupElementClass o +toHTMLOptGroupElement :: HTMLOptGroupElementClass o => o -> HTMLOptGroupElement +toHTMLOptGroupElement = unsafeCastGObject . toGObject + +instance HTMLOptGroupElementClass HTMLOptGroupElement +instance HTMLElementClass HTMLOptGroupElement +instance ElementClass HTMLOptGroupElement +instance NodeClass HTMLOptGroupElement +instance EventTargetClass HTMLOptGroupElement +instance GObjectClass HTMLOptGroupElement where + toGObject = GObject . castForeignPtr . unHTMLOptGroupElement + unsafeCastGObject = HTMLOptGroupElement . castForeignPtr . unGObject + +castToHTMLOptGroupElement :: GObjectClass obj => obj -> HTMLOptGroupElement +castToHTMLOptGroupElement = castTo gTypeHTMLOptGroupElement "HTMLOptGroupElement" + +gTypeHTMLOptGroupElement :: GType +gTypeHTMLOptGroupElement = + {# call fun unsafe webkit_dom_html_opt_group_element_get_type #} + +-- ********************************************************** HTMLOptionElement + +{#pointer *WebKitDOMHTMLOptionElement as HTMLOptionElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLOptionElement = (HTMLOptionElement, objectUnrefFromMainloop) +unHTMLOptionElement (HTMLOptionElement o) = o + +class HTMLElementClass o => HTMLOptionElementClass o +toHTMLOptionElement :: HTMLOptionElementClass o => o -> HTMLOptionElement +toHTMLOptionElement = unsafeCastGObject . toGObject + +instance HTMLOptionElementClass HTMLOptionElement +instance HTMLElementClass HTMLOptionElement +instance ElementClass HTMLOptionElement +instance NodeClass HTMLOptionElement +instance EventTargetClass HTMLOptionElement +instance GObjectClass HTMLOptionElement where + toGObject = GObject . castForeignPtr . unHTMLOptionElement + unsafeCastGObject = HTMLOptionElement . castForeignPtr . unGObject + +castToHTMLOptionElement :: GObjectClass obj => obj -> HTMLOptionElement +castToHTMLOptionElement = castTo gTypeHTMLOptionElement "HTMLOptionElement" + +gTypeHTMLOptionElement :: GType +gTypeHTMLOptionElement = + {# call fun unsafe webkit_dom_html_option_element_get_type #} + +-- ******************************************************* HTMLParagraphElement + +{#pointer *WebKitDOMHTMLParagraphElement as HTMLParagraphElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLParagraphElement = (HTMLParagraphElement, objectUnrefFromMainloop) +unHTMLParagraphElement (HTMLParagraphElement o) = o + +class HTMLElementClass o => HTMLParagraphElementClass o +toHTMLParagraphElement :: HTMLParagraphElementClass o => o -> HTMLParagraphElement +toHTMLParagraphElement = unsafeCastGObject . toGObject + +instance HTMLParagraphElementClass HTMLParagraphElement +instance HTMLElementClass HTMLParagraphElement +instance ElementClass HTMLParagraphElement +instance NodeClass HTMLParagraphElement +instance EventTargetClass HTMLParagraphElement +instance GObjectClass HTMLParagraphElement where + toGObject = GObject . castForeignPtr . unHTMLParagraphElement + unsafeCastGObject = HTMLParagraphElement . castForeignPtr . unGObject + +castToHTMLParagraphElement :: GObjectClass obj => obj -> HTMLParagraphElement +castToHTMLParagraphElement = castTo gTypeHTMLParagraphElement "HTMLParagraphElement" + +gTypeHTMLParagraphElement :: GType +gTypeHTMLParagraphElement = + {# call fun unsafe webkit_dom_html_paragraph_element_get_type #} + +-- *********************************************************** HTMLParamElement + +{#pointer *WebKitDOMHTMLParamElement as HTMLParamElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLParamElement = (HTMLParamElement, objectUnrefFromMainloop) +unHTMLParamElement (HTMLParamElement o) = o + +class HTMLElementClass o => HTMLParamElementClass o +toHTMLParamElement :: HTMLParamElementClass o => o -> HTMLParamElement +toHTMLParamElement = unsafeCastGObject . toGObject + +instance HTMLParamElementClass HTMLParamElement +instance HTMLElementClass HTMLParamElement +instance ElementClass HTMLParamElement +instance NodeClass HTMLParamElement +instance EventTargetClass HTMLParamElement +instance GObjectClass HTMLParamElement where + toGObject = GObject . castForeignPtr . unHTMLParamElement + unsafeCastGObject = HTMLParamElement . castForeignPtr . unGObject + +castToHTMLParamElement :: GObjectClass obj => obj -> HTMLParamElement +castToHTMLParamElement = castTo gTypeHTMLParamElement "HTMLParamElement" + +gTypeHTMLParamElement :: GType +gTypeHTMLParamElement = + {# call fun unsafe webkit_dom_html_param_element_get_type #} + +-- ************************************************************* HTMLPreElement + +{#pointer *WebKitDOMHTMLPreElement as HTMLPreElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLPreElement = (HTMLPreElement, objectUnrefFromMainloop) +unHTMLPreElement (HTMLPreElement o) = o + +class HTMLElementClass o => HTMLPreElementClass o +toHTMLPreElement :: HTMLPreElementClass o => o -> HTMLPreElement +toHTMLPreElement = unsafeCastGObject . toGObject + +instance HTMLPreElementClass HTMLPreElement +instance HTMLElementClass HTMLPreElement +instance ElementClass HTMLPreElement +instance NodeClass HTMLPreElement +instance EventTargetClass HTMLPreElement +instance GObjectClass HTMLPreElement where + toGObject = GObject . castForeignPtr . unHTMLPreElement + unsafeCastGObject = HTMLPreElement . castForeignPtr . unGObject + +castToHTMLPreElement :: GObjectClass obj => obj -> HTMLPreElement +castToHTMLPreElement = castTo gTypeHTMLPreElement "HTMLPreElement" + +gTypeHTMLPreElement :: GType +gTypeHTMLPreElement = + {# call fun unsafe webkit_dom_html_pre_element_get_type #} + +-- *********************************************************** HTMLQuoteElement + +{#pointer *WebKitDOMHTMLQuoteElement as HTMLQuoteElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLQuoteElement = (HTMLQuoteElement, objectUnrefFromMainloop) +unHTMLQuoteElement (HTMLQuoteElement o) = o + +class HTMLElementClass o => HTMLQuoteElementClass o +toHTMLQuoteElement :: HTMLQuoteElementClass o => o -> HTMLQuoteElement +toHTMLQuoteElement = unsafeCastGObject . toGObject + +instance HTMLQuoteElementClass HTMLQuoteElement +instance HTMLElementClass HTMLQuoteElement +instance ElementClass HTMLQuoteElement +instance NodeClass HTMLQuoteElement +instance EventTargetClass HTMLQuoteElement +instance GObjectClass HTMLQuoteElement where + toGObject = GObject . castForeignPtr . unHTMLQuoteElement + unsafeCastGObject = HTMLQuoteElement . castForeignPtr . unGObject + +castToHTMLQuoteElement :: GObjectClass obj => obj -> HTMLQuoteElement +castToHTMLQuoteElement = castTo gTypeHTMLQuoteElement "HTMLQuoteElement" + +gTypeHTMLQuoteElement :: GType +gTypeHTMLQuoteElement = + {# call fun unsafe webkit_dom_html_quote_element_get_type #} + +-- ********************************************************** HTMLScriptElement + +{#pointer *WebKitDOMHTMLScriptElement as HTMLScriptElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLScriptElement = (HTMLScriptElement, objectUnrefFromMainloop) +unHTMLScriptElement (HTMLScriptElement o) = o + +class HTMLElementClass o => HTMLScriptElementClass o +toHTMLScriptElement :: HTMLScriptElementClass o => o -> HTMLScriptElement +toHTMLScriptElement = unsafeCastGObject . toGObject + +instance HTMLScriptElementClass HTMLScriptElement +instance HTMLElementClass HTMLScriptElement +instance ElementClass HTMLScriptElement +instance NodeClass HTMLScriptElement +instance EventTargetClass HTMLScriptElement +instance GObjectClass HTMLScriptElement where + toGObject = GObject . castForeignPtr . unHTMLScriptElement + unsafeCastGObject = HTMLScriptElement . castForeignPtr . unGObject + +castToHTMLScriptElement :: GObjectClass obj => obj -> HTMLScriptElement +castToHTMLScriptElement = castTo gTypeHTMLScriptElement "HTMLScriptElement" + +gTypeHTMLScriptElement :: GType +gTypeHTMLScriptElement = + {# call fun unsafe webkit_dom_html_script_element_get_type #} + +-- ********************************************************** HTMLSelectElement + +{#pointer *WebKitDOMHTMLSelectElement as HTMLSelectElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLSelectElement = (HTMLSelectElement, objectUnrefFromMainloop) +unHTMLSelectElement (HTMLSelectElement o) = o + +class HTMLElementClass o => HTMLSelectElementClass o +toHTMLSelectElement :: HTMLSelectElementClass o => o -> HTMLSelectElement +toHTMLSelectElement = unsafeCastGObject . toGObject + +instance HTMLSelectElementClass HTMLSelectElement +instance HTMLElementClass HTMLSelectElement +instance ElementClass HTMLSelectElement +instance NodeClass HTMLSelectElement +instance EventTargetClass HTMLSelectElement +instance GObjectClass HTMLSelectElement where + toGObject = GObject . castForeignPtr . unHTMLSelectElement + unsafeCastGObject = HTMLSelectElement . castForeignPtr . unGObject + +castToHTMLSelectElement :: GObjectClass obj => obj -> HTMLSelectElement +castToHTMLSelectElement = castTo gTypeHTMLSelectElement "HTMLSelectElement" + +gTypeHTMLSelectElement :: GType +gTypeHTMLSelectElement = + {# call fun unsafe webkit_dom_html_select_element_get_type #} + +-- *********************************************************** HTMLStyleElement + +{#pointer *WebKitDOMHTMLStyleElement as HTMLStyleElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLStyleElement = (HTMLStyleElement, objectUnrefFromMainloop) +unHTMLStyleElement (HTMLStyleElement o) = o + +class HTMLElementClass o => HTMLStyleElementClass o +toHTMLStyleElement :: HTMLStyleElementClass o => o -> HTMLStyleElement +toHTMLStyleElement = unsafeCastGObject . toGObject + +instance HTMLStyleElementClass HTMLStyleElement +instance HTMLElementClass HTMLStyleElement +instance ElementClass HTMLStyleElement +instance NodeClass HTMLStyleElement +instance EventTargetClass HTMLStyleElement +instance GObjectClass HTMLStyleElement where + toGObject = GObject . castForeignPtr . unHTMLStyleElement + unsafeCastGObject = HTMLStyleElement . castForeignPtr . unGObject + +castToHTMLStyleElement :: GObjectClass obj => obj -> HTMLStyleElement +castToHTMLStyleElement = castTo gTypeHTMLStyleElement "HTMLStyleElement" + +gTypeHTMLStyleElement :: GType +gTypeHTMLStyleElement = + {# call fun unsafe webkit_dom_html_style_element_get_type #} + +-- **************************************************** HTMLTableCaptionElement + +{#pointer *WebKitDOMHTMLTableCaptionElement as HTMLTableCaptionElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLTableCaptionElement = (HTMLTableCaptionElement, objectUnrefFromMainloop) +unHTMLTableCaptionElement (HTMLTableCaptionElement o) = o + +class HTMLElementClass o => HTMLTableCaptionElementClass o +toHTMLTableCaptionElement :: HTMLTableCaptionElementClass o => o -> HTMLTableCaptionElement +toHTMLTableCaptionElement = unsafeCastGObject . toGObject + +instance HTMLTableCaptionElementClass HTMLTableCaptionElement +instance HTMLElementClass HTMLTableCaptionElement +instance ElementClass HTMLTableCaptionElement +instance NodeClass HTMLTableCaptionElement +instance EventTargetClass HTMLTableCaptionElement +instance GObjectClass HTMLTableCaptionElement where + toGObject = GObject . castForeignPtr . unHTMLTableCaptionElement + unsafeCastGObject = HTMLTableCaptionElement . castForeignPtr . unGObject + +castToHTMLTableCaptionElement :: GObjectClass obj => obj -> HTMLTableCaptionElement +castToHTMLTableCaptionElement = castTo gTypeHTMLTableCaptionElement "HTMLTableCaptionElement" + +gTypeHTMLTableCaptionElement :: GType +gTypeHTMLTableCaptionElement = + {# call fun unsafe webkit_dom_html_table_caption_element_get_type #} + +-- ******************************************************* HTMLTableCellElement + +{#pointer *WebKitDOMHTMLTableCellElement as HTMLTableCellElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLTableCellElement = (HTMLTableCellElement, objectUnrefFromMainloop) +unHTMLTableCellElement (HTMLTableCellElement o) = o + +class HTMLElementClass o => HTMLTableCellElementClass o +toHTMLTableCellElement :: HTMLTableCellElementClass o => o -> HTMLTableCellElement +toHTMLTableCellElement = unsafeCastGObject . toGObject + +instance HTMLTableCellElementClass HTMLTableCellElement +instance HTMLElementClass HTMLTableCellElement +instance ElementClass HTMLTableCellElement +instance NodeClass HTMLTableCellElement +instance EventTargetClass HTMLTableCellElement +instance GObjectClass HTMLTableCellElement where + toGObject = GObject . castForeignPtr . unHTMLTableCellElement + unsafeCastGObject = HTMLTableCellElement . castForeignPtr . unGObject + +castToHTMLTableCellElement :: GObjectClass obj => obj -> HTMLTableCellElement +castToHTMLTableCellElement = castTo gTypeHTMLTableCellElement "HTMLTableCellElement" + +gTypeHTMLTableCellElement :: GType +gTypeHTMLTableCellElement = + {# call fun unsafe webkit_dom_html_table_cell_element_get_type #} + +-- ******************************************************** HTMLTableColElement + +{#pointer *WebKitDOMHTMLTableColElement as HTMLTableColElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLTableColElement = (HTMLTableColElement, objectUnrefFromMainloop) +unHTMLTableColElement (HTMLTableColElement o) = o + +class HTMLElementClass o => HTMLTableColElementClass o +toHTMLTableColElement :: HTMLTableColElementClass o => o -> HTMLTableColElement +toHTMLTableColElement = unsafeCastGObject . toGObject + +instance HTMLTableColElementClass HTMLTableColElement +instance HTMLElementClass HTMLTableColElement +instance ElementClass HTMLTableColElement +instance NodeClass HTMLTableColElement +instance EventTargetClass HTMLTableColElement +instance GObjectClass HTMLTableColElement where + toGObject = GObject . castForeignPtr . unHTMLTableColElement + unsafeCastGObject = HTMLTableColElement . castForeignPtr . unGObject + +castToHTMLTableColElement :: GObjectClass obj => obj -> HTMLTableColElement +castToHTMLTableColElement = castTo gTypeHTMLTableColElement "HTMLTableColElement" + +gTypeHTMLTableColElement :: GType +gTypeHTMLTableColElement = + {# call fun unsafe webkit_dom_html_table_col_element_get_type #} + +-- *********************************************************** HTMLTableElement + +{#pointer *WebKitDOMHTMLTableElement as HTMLTableElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLTableElement = (HTMLTableElement, objectUnrefFromMainloop) +unHTMLTableElement (HTMLTableElement o) = o + +class HTMLElementClass o => HTMLTableElementClass o +toHTMLTableElement :: HTMLTableElementClass o => o -> HTMLTableElement +toHTMLTableElement = unsafeCastGObject . toGObject + +instance HTMLTableElementClass HTMLTableElement +instance HTMLElementClass HTMLTableElement +instance ElementClass HTMLTableElement +instance NodeClass HTMLTableElement +instance EventTargetClass HTMLTableElement +instance GObjectClass HTMLTableElement where + toGObject = GObject . castForeignPtr . unHTMLTableElement + unsafeCastGObject = HTMLTableElement . castForeignPtr . unGObject + +castToHTMLTableElement :: GObjectClass obj => obj -> HTMLTableElement +castToHTMLTableElement = castTo gTypeHTMLTableElement "HTMLTableElement" + +gTypeHTMLTableElement :: GType +gTypeHTMLTableElement = + {# call fun unsafe webkit_dom_html_table_element_get_type #} + +-- ******************************************************** HTMLTableRowElement + +{#pointer *WebKitDOMHTMLTableRowElement as HTMLTableRowElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLTableRowElement = (HTMLTableRowElement, objectUnrefFromMainloop) +unHTMLTableRowElement (HTMLTableRowElement o) = o + +class HTMLElementClass o => HTMLTableRowElementClass o +toHTMLTableRowElement :: HTMLTableRowElementClass o => o -> HTMLTableRowElement +toHTMLTableRowElement = unsafeCastGObject . toGObject + +instance HTMLTableRowElementClass HTMLTableRowElement +instance HTMLElementClass HTMLTableRowElement +instance ElementClass HTMLTableRowElement +instance NodeClass HTMLTableRowElement +instance EventTargetClass HTMLTableRowElement +instance GObjectClass HTMLTableRowElement where + toGObject = GObject . castForeignPtr . unHTMLTableRowElement + unsafeCastGObject = HTMLTableRowElement . castForeignPtr . unGObject + +castToHTMLTableRowElement :: GObjectClass obj => obj -> HTMLTableRowElement +castToHTMLTableRowElement = castTo gTypeHTMLTableRowElement "HTMLTableRowElement" + +gTypeHTMLTableRowElement :: GType +gTypeHTMLTableRowElement = + {# call fun unsafe webkit_dom_html_table_row_element_get_type #} + +-- **************************************************** HTMLTableSectionElement + +{#pointer *WebKitDOMHTMLTableSectionElement as HTMLTableSectionElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLTableSectionElement = (HTMLTableSectionElement, objectUnrefFromMainloop) +unHTMLTableSectionElement (HTMLTableSectionElement o) = o + +class HTMLElementClass o => HTMLTableSectionElementClass o +toHTMLTableSectionElement :: HTMLTableSectionElementClass o => o -> HTMLTableSectionElement +toHTMLTableSectionElement = unsafeCastGObject . toGObject + +instance HTMLTableSectionElementClass HTMLTableSectionElement +instance HTMLElementClass HTMLTableSectionElement +instance ElementClass HTMLTableSectionElement +instance NodeClass HTMLTableSectionElement +instance EventTargetClass HTMLTableSectionElement +instance GObjectClass HTMLTableSectionElement where + toGObject = GObject . castForeignPtr . unHTMLTableSectionElement + unsafeCastGObject = HTMLTableSectionElement . castForeignPtr . unGObject + +castToHTMLTableSectionElement :: GObjectClass obj => obj -> HTMLTableSectionElement +castToHTMLTableSectionElement = castTo gTypeHTMLTableSectionElement "HTMLTableSectionElement" + +gTypeHTMLTableSectionElement :: GType +gTypeHTMLTableSectionElement = + {# call fun unsafe webkit_dom_html_table_section_element_get_type #} + +-- ******************************************************** HTMLTextAreaElement + +{#pointer *WebKitDOMHTMLTextAreaElement as HTMLTextAreaElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLTextAreaElement = (HTMLTextAreaElement, objectUnrefFromMainloop) +unHTMLTextAreaElement (HTMLTextAreaElement o) = o + +class HTMLElementClass o => HTMLTextAreaElementClass o +toHTMLTextAreaElement :: HTMLTextAreaElementClass o => o -> HTMLTextAreaElement +toHTMLTextAreaElement = unsafeCastGObject . toGObject + +instance HTMLTextAreaElementClass HTMLTextAreaElement +instance HTMLElementClass HTMLTextAreaElement +instance ElementClass HTMLTextAreaElement +instance NodeClass HTMLTextAreaElement +instance EventTargetClass HTMLTextAreaElement +instance GObjectClass HTMLTextAreaElement where + toGObject = GObject . castForeignPtr . unHTMLTextAreaElement + unsafeCastGObject = HTMLTextAreaElement . castForeignPtr . unGObject + +castToHTMLTextAreaElement :: GObjectClass obj => obj -> HTMLTextAreaElement +castToHTMLTextAreaElement = castTo gTypeHTMLTextAreaElement "HTMLTextAreaElement" + +gTypeHTMLTextAreaElement :: GType +gTypeHTMLTextAreaElement = + {# call fun unsafe webkit_dom_html_text_area_element_get_type #} + +-- *********************************************************** HTMLTitleElement + +{#pointer *WebKitDOMHTMLTitleElement as HTMLTitleElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLTitleElement = (HTMLTitleElement, objectUnrefFromMainloop) +unHTMLTitleElement (HTMLTitleElement o) = o + +class HTMLElementClass o => HTMLTitleElementClass o +toHTMLTitleElement :: HTMLTitleElementClass o => o -> HTMLTitleElement +toHTMLTitleElement = unsafeCastGObject . toGObject + +instance HTMLTitleElementClass HTMLTitleElement +instance HTMLElementClass HTMLTitleElement +instance ElementClass HTMLTitleElement +instance NodeClass HTMLTitleElement +instance EventTargetClass HTMLTitleElement +instance GObjectClass HTMLTitleElement where + toGObject = GObject . castForeignPtr . unHTMLTitleElement + unsafeCastGObject = HTMLTitleElement . castForeignPtr . unGObject + +castToHTMLTitleElement :: GObjectClass obj => obj -> HTMLTitleElement +castToHTMLTitleElement = castTo gTypeHTMLTitleElement "HTMLTitleElement" + +gTypeHTMLTitleElement :: GType +gTypeHTMLTitleElement = + {# call fun unsafe webkit_dom_html_title_element_get_type #} + +-- *********************************************************** HTMLUListElement + +{#pointer *WebKitDOMHTMLUListElement as HTMLUListElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLUListElement = (HTMLUListElement, objectUnrefFromMainloop) +unHTMLUListElement (HTMLUListElement o) = o + +class HTMLElementClass o => HTMLUListElementClass o +toHTMLUListElement :: HTMLUListElementClass o => o -> HTMLUListElement +toHTMLUListElement = unsafeCastGObject . toGObject + +instance HTMLUListElementClass HTMLUListElement +instance HTMLElementClass HTMLUListElement +instance ElementClass HTMLUListElement +instance NodeClass HTMLUListElement +instance EventTargetClass HTMLUListElement +instance GObjectClass HTMLUListElement where + toGObject = GObject . castForeignPtr . unHTMLUListElement + unsafeCastGObject = HTMLUListElement . castForeignPtr . unGObject + +castToHTMLUListElement :: GObjectClass obj => obj -> HTMLUListElement +castToHTMLUListElement = castTo gTypeHTMLUListElement "HTMLUListElement" + +gTypeHTMLUListElement :: GType +gTypeHTMLUListElement = + {# call fun unsafe webkit_dom_htmlu_list_element_get_type #} + +-- ************************************************************ EntityReference + +{#pointer *WebKitDOMEntityReference as EntityReference foreign newtype #} deriving (Eq,Ord) + +mkEntityReference = (EntityReference, objectUnrefFromMainloop) +unEntityReference (EntityReference o) = o + +class NodeClass o => EntityReferenceClass o +toEntityReference :: EntityReferenceClass o => o -> EntityReference +toEntityReference = unsafeCastGObject . toGObject + +instance EntityReferenceClass EntityReference +instance NodeClass EntityReference +instance EventTargetClass EntityReference +instance GObjectClass EntityReference where + toGObject = GObject . castForeignPtr . unEntityReference + unsafeCastGObject = EntityReference . castForeignPtr . unGObject + +castToEntityReference :: GObjectClass obj => obj -> EntityReference +castToEntityReference = castTo gTypeEntityReference "EntityReference" + +gTypeEntityReference :: GType +gTypeEntityReference = + {# call fun unsafe webkit_dom_entity_reference_get_type #} + +-- **************************************************************** Performance + +{#pointer *WebKitDOMPerformance as Performance foreign newtype #} deriving (Eq,Ord) + +mkPerformance = (Performance, objectUnrefFromMainloop) +unPerformance (Performance o) = o + +class EventTargetClass o => PerformanceClass o +toPerformance :: PerformanceClass o => o -> Performance +toPerformance = unsafeCastGObject . toGObject + +instance PerformanceClass Performance +instance EventTargetClass Performance +instance GObjectClass Performance where + toGObject = GObject . castForeignPtr . unPerformance + unsafeCastGObject = Performance . castForeignPtr . unGObject + +castToPerformance :: GObjectClass obj => obj -> Performance +castToPerformance = castTo gTypePerformance "Performance" + +gTypePerformance :: GType +gTypePerformance = + {# call fun unsafe webkit_dom_performance_get_type #} + +-- ****************************************************************** TextTrack + +{#pointer *WebKitDOMTextTrack as TextTrack foreign newtype #} deriving (Eq,Ord) + +mkTextTrack = (TextTrack, objectUnrefFromMainloop) +unTextTrack (TextTrack o) = o + +class EventTargetClass o => TextTrackClass o +toTextTrack :: TextTrackClass o => o -> TextTrack +toTextTrack = unsafeCastGObject . toGObject + +instance TextTrackClass TextTrack +instance EventTargetClass TextTrack +instance GObjectClass TextTrack where + toGObject = GObject . castForeignPtr . unTextTrack + unsafeCastGObject = TextTrack . castForeignPtr . unGObject + +castToTextTrack :: GObjectClass obj => obj -> TextTrack +castToTextTrack = castTo gTypeTextTrack "TextTrack" + +gTypeTextTrack :: GType +gTypeTextTrack = + {# call fun unsafe webkit_dom_text_track_get_type #} + +-- *************************************************************** TextTrackCue + +{#pointer *WebKitDOMTextTrackCue as TextTrackCue foreign newtype #} deriving (Eq,Ord) + +mkTextTrackCue = (TextTrackCue, objectUnrefFromMainloop) +unTextTrackCue (TextTrackCue o) = o + +class EventTargetClass o => TextTrackCueClass o +toTextTrackCue :: TextTrackCueClass o => o -> TextTrackCue +toTextTrackCue = unsafeCastGObject . toGObject + +instance TextTrackCueClass TextTrackCue +instance EventTargetClass TextTrackCue +instance GObjectClass TextTrackCue where + toGObject = GObject . castForeignPtr . unTextTrackCue + unsafeCastGObject = TextTrackCue . castForeignPtr . unGObject + +castToTextTrackCue :: GObjectClass obj => obj -> TextTrackCue +castToTextTrackCue = castTo gTypeTextTrackCue "TextTrackCue" + +gTypeTextTrackCue :: GType +gTypeTextTrackCue = + {# call fun unsafe webkit_dom_text_track_cue_get_type #} + +-- ************************************************************** TextTrackList + +{#pointer *WebKitDOMTextTrackList as TextTrackList foreign newtype #} deriving (Eq,Ord) + +mkTextTrackList = (TextTrackList, objectUnrefFromMainloop) +unTextTrackList (TextTrackList o) = o + +class EventTargetClass o => TextTrackListClass o +toTextTrackList :: TextTrackListClass o => o -> TextTrackList +toTextTrackList = unsafeCastGObject . toGObject + +instance TextTrackListClass TextTrackList +instance EventTargetClass TextTrackList +instance GObjectClass TextTrackList where + toGObject = GObject . castForeignPtr . unTextTrackList + unsafeCastGObject = TextTrackList . castForeignPtr . unGObject + +castToTextTrackList :: GObjectClass obj => obj -> TextTrackList +castToTextTrackList = castTo gTypeTextTrackList "TextTrackList" + +gTypeTextTrackList :: GType +gTypeTextTrackList = + {# call fun unsafe webkit_dom_text_track_list_get_type #} + +-- ************************************************************* VideoTrackList + +{#pointer *WebKitDOMVideoTrackList as VideoTrackList foreign newtype #} deriving (Eq,Ord) + +mkVideoTrackList = (VideoTrackList, objectUnrefFromMainloop) +unVideoTrackList (VideoTrackList o) = o + +class EventTargetClass o => VideoTrackListClass o +toVideoTrackList :: VideoTrackListClass o => o -> VideoTrackList +toVideoTrackList = unsafeCastGObject . toGObject + +instance VideoTrackListClass VideoTrackList +instance EventTargetClass VideoTrackList +instance GObjectClass VideoTrackList where + toGObject = GObject . castForeignPtr . unVideoTrackList + unsafeCastGObject = VideoTrackList . castForeignPtr . unGObject + +castToVideoTrackList :: GObjectClass obj => obj -> VideoTrackList +castToVideoTrackList = castTo gTypeVideoTrackList "VideoTrackList" + +gTypeVideoTrackList :: GType +gTypeVideoTrackList = + {# call fun unsafe webkit_dom_video_track_list_get_type #} + +-- ************************************************************ WebKitNamedFlow + +{#pointer *WebKitDOMWebKitNamedFlow as WebKitNamedFlow foreign newtype #} deriving (Eq,Ord) + +mkWebKitNamedFlow = (WebKitNamedFlow, objectUnrefFromMainloop) +unWebKitNamedFlow (WebKitNamedFlow o) = o + +class EventTargetClass o => WebKitNamedFlowClass o +toWebKitNamedFlow :: WebKitNamedFlowClass o => o -> WebKitNamedFlow +toWebKitNamedFlow = unsafeCastGObject . toGObject + +instance WebKitNamedFlowClass WebKitNamedFlow +instance EventTargetClass WebKitNamedFlow +instance GObjectClass WebKitNamedFlow where + toGObject = GObject . castForeignPtr . unWebKitNamedFlow + unsafeCastGObject = WebKitNamedFlow . castForeignPtr . unGObject + +castToWebKitNamedFlow :: GObjectClass obj => obj -> WebKitNamedFlow +castToWebKitNamedFlow = castTo gTypeWebKitNamedFlow "WebKitNamedFlow" + +gTypeWebKitNamedFlow :: GType +gTypeWebKitNamedFlow = + {# call fun unsafe webkit_dom_webkit_named_flow_get_type #} + +-- ********************************************************************* Window + +{#pointer *WebKitDOMDOMWindow as Window foreign newtype #} deriving (Eq,Ord) + +mkWindow = (Window, objectUnrefFromMainloop) +unWindow (Window o) = o + +class EventTargetClass o => WindowClass o +toWindow :: WindowClass o => o -> Window +toWindow = unsafeCastGObject . toGObject + +instance WindowClass Window +instance EventTargetClass Window +instance GObjectClass Window where + toGObject = GObject . castForeignPtr . unWindow + unsafeCastGObject = Window . castForeignPtr . unGObject + +castToWindow :: GObjectClass obj => obj -> Window +castToWindow = castTo gTypeWindow "Window" + +gTypeWindow :: GType +gTypeWindow = + {# call fun unsafe webkit_dom_dom_window_get_type #} + +-- ******************************************************************* FileList + +{#pointer *WebKitDOMFileList as FileList foreign newtype #} deriving (Eq,Ord) + +mkFileList = (FileList, objectUnrefFromMainloop) +unFileList (FileList o) = o + +class GObjectClass o => FileListClass o +toFileList :: FileListClass o => o -> FileList +toFileList = unsafeCastGObject . toGObject + +instance FileListClass FileList +instance GObjectClass FileList where + toGObject = GObject . castForeignPtr . unFileList + unsafeCastGObject = FileList . castForeignPtr . unGObject + +castToFileList :: GObjectClass obj => obj -> FileList +castToFileList = castTo gTypeFileList "FileList" + +gTypeFileList :: GType +gTypeFileList = + {# call fun unsafe webkit_dom_file_list_get_type #} + +-- **************************************************************** Geolocation + +{#pointer *WebKitDOMGeolocation as Geolocation foreign newtype #} deriving (Eq,Ord) + +mkGeolocation = (Geolocation, objectUnrefFromMainloop) +unGeolocation (Geolocation o) = o + +class GObjectClass o => GeolocationClass o +toGeolocation :: GeolocationClass o => o -> Geolocation +toGeolocation = unsafeCastGObject . toGObject + +instance GeolocationClass Geolocation +instance GObjectClass Geolocation where + toGObject = GObject . castForeignPtr . unGeolocation + unsafeCastGObject = Geolocation . castForeignPtr . unGObject + +castToGeolocation :: GObjectClass obj => obj -> Geolocation +castToGeolocation = castTo gTypeGeolocation "Geolocation" + +gTypeGeolocation :: GType +gTypeGeolocation = + {# call fun unsafe webkit_dom_geolocation_get_type #} + +-- ************************************************************* HTMLCollection + +{#pointer *WebKitDOMHTMLCollection as HTMLCollection foreign newtype #} deriving (Eq,Ord) + +mkHTMLCollection = (HTMLCollection, objectUnrefFromMainloop) +unHTMLCollection (HTMLCollection o) = o + +class GObjectClass o => HTMLCollectionClass o +toHTMLCollection :: HTMLCollectionClass o => o -> HTMLCollection +toHTMLCollection = unsafeCastGObject . toGObject + +instance HTMLCollectionClass HTMLCollection +instance GObjectClass HTMLCollection where + toGObject = GObject . castForeignPtr . unHTMLCollection + unsafeCastGObject = HTMLCollection . castForeignPtr . unGObject + +castToHTMLCollection :: GObjectClass obj => obj -> HTMLCollection +castToHTMLCollection = castTo gTypeHTMLCollection "HTMLCollection" + +gTypeHTMLCollection :: GType +gTypeHTMLCollection = + {# call fun unsafe webkit_dom_html_collection_get_type #} + +-- ****************************************************** HTMLOptionsCollection + +{#pointer *WebKitDOMHTMLOptionsCollection as HTMLOptionsCollection foreign newtype #} deriving (Eq,Ord) + +mkHTMLOptionsCollection = (HTMLOptionsCollection, objectUnrefFromMainloop) +unHTMLOptionsCollection (HTMLOptionsCollection o) = o + +class HTMLCollectionClass o => HTMLOptionsCollectionClass o +toHTMLOptionsCollection :: HTMLOptionsCollectionClass o => o -> HTMLOptionsCollection +toHTMLOptionsCollection = unsafeCastGObject . toGObject + +instance HTMLOptionsCollectionClass HTMLOptionsCollection +instance HTMLCollectionClass HTMLOptionsCollection +instance GObjectClass HTMLOptionsCollection where + toGObject = GObject . castForeignPtr . unHTMLOptionsCollection + unsafeCastGObject = HTMLOptionsCollection . castForeignPtr . unGObject + +castToHTMLOptionsCollection :: GObjectClass obj => obj -> HTMLOptionsCollection +castToHTMLOptionsCollection = castTo gTypeHTMLOptionsCollection "HTMLOptionsCollection" + +gTypeHTMLOptionsCollection :: GType +gTypeHTMLOptionsCollection = + {# call fun unsafe webkit_dom_html_options_collection_get_type #} + +-- *********************************************************** HTMLMediaElement + +{#pointer *WebKitDOMHTMLMediaElement as HTMLMediaElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLMediaElement = (HTMLMediaElement, objectUnrefFromMainloop) +unHTMLMediaElement (HTMLMediaElement o) = o + +class GObjectClass o => HTMLMediaElementClass o +toHTMLMediaElement :: HTMLMediaElementClass o => o -> HTMLMediaElement +toHTMLMediaElement = unsafeCastGObject . toGObject + +instance HTMLMediaElementClass HTMLMediaElement +instance GObjectClass HTMLMediaElement where + toGObject = GObject . castForeignPtr . unHTMLMediaElement + unsafeCastGObject = HTMLMediaElement . castForeignPtr . unGObject + +castToHTMLMediaElement :: GObjectClass obj => obj -> HTMLMediaElement +castToHTMLMediaElement = castTo gTypeHTMLMediaElement "HTMLMediaElement" + +gTypeHTMLMediaElement :: GType +gTypeHTMLMediaElement = + {# call fun unsafe webkit_dom_html_media_element_get_type #} + +-- *********************************************************** HTMLAudioElement + +{#pointer *WebKitDOMHTMLAudioElement as HTMLAudioElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLAudioElement = (HTMLAudioElement, objectUnrefFromMainloop) +unHTMLAudioElement (HTMLAudioElement o) = o + +class HTMLMediaElementClass o => HTMLAudioElementClass o +toHTMLAudioElement :: HTMLAudioElementClass o => o -> HTMLAudioElement +toHTMLAudioElement = unsafeCastGObject . toGObject + +instance HTMLAudioElementClass HTMLAudioElement +instance HTMLMediaElementClass HTMLAudioElement +instance GObjectClass HTMLAudioElement where + toGObject = GObject . castForeignPtr . unHTMLAudioElement + unsafeCastGObject = HTMLAudioElement . castForeignPtr . unGObject + +castToHTMLAudioElement :: GObjectClass obj => obj -> HTMLAudioElement +castToHTMLAudioElement = castTo gTypeHTMLAudioElement "HTMLAudioElement" + +gTypeHTMLAudioElement :: GType +gTypeHTMLAudioElement = + {# call fun unsafe webkit_dom_html_audio_element_get_type #} + +-- *********************************************************** HTMLVideoElement + +{#pointer *WebKitDOMHTMLVideoElement as HTMLVideoElement foreign newtype #} deriving (Eq,Ord) + +mkHTMLVideoElement = (HTMLVideoElement, objectUnrefFromMainloop) +unHTMLVideoElement (HTMLVideoElement o) = o + +class HTMLMediaElementClass o => HTMLVideoElementClass o +toHTMLVideoElement :: HTMLVideoElementClass o => o -> HTMLVideoElement +toHTMLVideoElement = unsafeCastGObject . toGObject + +instance HTMLVideoElementClass HTMLVideoElement +instance HTMLMediaElementClass HTMLVideoElement +instance GObjectClass HTMLVideoElement where + toGObject = GObject . castForeignPtr . unHTMLVideoElement + unsafeCastGObject = HTMLVideoElement . castForeignPtr . unGObject + +castToHTMLVideoElement :: GObjectClass obj => obj -> HTMLVideoElement +castToHTMLVideoElement = castTo gTypeHTMLVideoElement "HTMLVideoElement" + +gTypeHTMLVideoElement :: GType +gTypeHTMLVideoElement = + {# call fun unsafe webkit_dom_html_video_element_get_type #} + +-- ******************************************************************** History + +{#pointer *WebKitDOMHistory as History foreign newtype #} deriving (Eq,Ord) + +mkHistory = (History, objectUnrefFromMainloop) +unHistory (History o) = o + +class GObjectClass o => HistoryClass o +toHistory :: HistoryClass o => o -> History +toHistory = unsafeCastGObject . toGObject + +instance HistoryClass History +instance GObjectClass History where + toGObject = GObject . castForeignPtr . unHistory + unsafeCastGObject = History . castForeignPtr . unGObject + +castToHistory :: GObjectClass obj => obj -> History +castToHistory = castTo gTypeHistory "History" + +gTypeHistory :: GType +gTypeHistory = + {# call fun unsafe webkit_dom_history_get_type #} + +-- ******************************************************************* Location + +{#pointer *WebKitDOMLocation as Location foreign newtype #} deriving (Eq,Ord) + +mkLocation = (Location, objectUnrefFromMainloop) +unLocation (Location o) = o + +class GObjectClass o => LocationClass o +toLocation :: LocationClass o => o -> Location +toLocation = unsafeCastGObject . toGObject + +instance LocationClass Location +instance GObjectClass Location where + toGObject = GObject . castForeignPtr . unLocation + unsafeCastGObject = Location . castForeignPtr . unGObject + +castToLocation :: GObjectClass obj => obj -> Location +castToLocation = castTo gTypeLocation "Location" + +gTypeLocation :: GType +gTypeLocation = + {# call fun unsafe webkit_dom_location_get_type #} + +-- ***************************************************************** MediaError + +{#pointer *WebKitDOMMediaError as MediaError foreign newtype #} deriving (Eq,Ord) + +mkMediaError = (MediaError, objectUnrefFromMainloop) +unMediaError (MediaError o) = o + +class GObjectClass o => MediaErrorClass o +toMediaError :: MediaErrorClass o => o -> MediaError +toMediaError = unsafeCastGObject . toGObject + +instance MediaErrorClass MediaError +instance GObjectClass MediaError where + toGObject = GObject . castForeignPtr . unMediaError + unsafeCastGObject = MediaError . castForeignPtr . unGObject + +castToMediaError :: GObjectClass obj => obj -> MediaError +castToMediaError = castTo gTypeMediaError "MediaError" + +gTypeMediaError :: GType +gTypeMediaError = + {# call fun unsafe webkit_dom_media_error_get_type #} + +-- ****************************************************************** MediaList + +{#pointer *WebKitDOMMediaList as MediaList foreign newtype #} deriving (Eq,Ord) + +mkMediaList = (MediaList, objectUnrefFromMainloop) +unMediaList (MediaList o) = o + +class GObjectClass o => MediaListClass o +toMediaList :: MediaListClass o => o -> MediaList +toMediaList = unsafeCastGObject . toGObject + +instance MediaListClass MediaList +instance GObjectClass MediaList where + toGObject = GObject . castForeignPtr . unMediaList + unsafeCastGObject = MediaList . castForeignPtr . unGObject + +castToMediaList :: GObjectClass obj => obj -> MediaList +castToMediaList = castTo gTypeMediaList "MediaList" + +gTypeMediaList :: GType +gTypeMediaList = + {# call fun unsafe webkit_dom_media_list_get_type #} + +-- ************************************************************* MediaQueryList + +{#pointer *WebKitDOMMediaQueryList as MediaQueryList foreign newtype #} deriving (Eq,Ord) + +mkMediaQueryList = (MediaQueryList, objectUnrefFromMainloop) +unMediaQueryList (MediaQueryList o) = o + +class GObjectClass o => MediaQueryListClass o +toMediaQueryList :: MediaQueryListClass o => o -> MediaQueryList +toMediaQueryList = unsafeCastGObject . toGObject + +instance MediaQueryListClass MediaQueryList +instance GObjectClass MediaQueryList where + toGObject = GObject . castForeignPtr . unMediaQueryList + unsafeCastGObject = MediaQueryList . castForeignPtr . unGObject + +castToMediaQueryList :: GObjectClass obj => obj -> MediaQueryList +castToMediaQueryList = castTo gTypeMediaQueryList "MediaQueryList" + +gTypeMediaQueryList :: GType +gTypeMediaQueryList = + {# call fun unsafe webkit_dom_media_query_list_get_type #} + +-- ******************************************************************* MimeType + +{#pointer *WebKitDOMDOMMimeType as MimeType foreign newtype #} deriving (Eq,Ord) + +mkMimeType = (MimeType, objectUnrefFromMainloop) +unMimeType (MimeType o) = o + +class GObjectClass o => MimeTypeClass o +toMimeType :: MimeTypeClass o => o -> MimeType +toMimeType = unsafeCastGObject . toGObject + +instance MimeTypeClass MimeType +instance GObjectClass MimeType where + toGObject = GObject . castForeignPtr . unMimeType + unsafeCastGObject = MimeType . castForeignPtr . unGObject + +castToMimeType :: GObjectClass obj => obj -> MimeType +castToMimeType = castTo gTypeMimeType "MimeType" + +gTypeMimeType :: GType +gTypeMimeType = + {# call fun unsafe webkit_dom_dom_mime_type_get_type #} + +-- ************************************************************** MimeTypeArray + +{#pointer *WebKitDOMDOMMimeTypeArray as MimeTypeArray foreign newtype #} deriving (Eq,Ord) + +mkMimeTypeArray = (MimeTypeArray, objectUnrefFromMainloop) +unMimeTypeArray (MimeTypeArray o) = o + +class GObjectClass o => MimeTypeArrayClass o +toMimeTypeArray :: MimeTypeArrayClass o => o -> MimeTypeArray +toMimeTypeArray = unsafeCastGObject . toGObject + +instance MimeTypeArrayClass MimeTypeArray +instance GObjectClass MimeTypeArray where + toGObject = GObject . castForeignPtr . unMimeTypeArray + unsafeCastGObject = MimeTypeArray . castForeignPtr . unGObject + +castToMimeTypeArray :: GObjectClass obj => obj -> MimeTypeArray +castToMimeTypeArray = castTo gTypeMimeTypeArray "MimeTypeArray" + +gTypeMimeTypeArray :: GType +gTypeMimeTypeArray = + {# call fun unsafe webkit_dom_dom_mime_type_array_get_type #} + +-- *************************************************************** NamedNodeMap + +{#pointer *WebKitDOMNamedNodeMap as NamedNodeMap foreign newtype #} deriving (Eq,Ord) + +mkNamedNodeMap = (NamedNodeMap, objectUnrefFromMainloop) +unNamedNodeMap (NamedNodeMap o) = o + +class GObjectClass o => NamedNodeMapClass o +toNamedNodeMap :: NamedNodeMapClass o => o -> NamedNodeMap +toNamedNodeMap = unsafeCastGObject . toGObject + +instance NamedNodeMapClass NamedNodeMap +instance GObjectClass NamedNodeMap where + toGObject = GObject . castForeignPtr . unNamedNodeMap + unsafeCastGObject = NamedNodeMap . castForeignPtr . unGObject + +castToNamedNodeMap :: GObjectClass obj => obj -> NamedNodeMap +castToNamedNodeMap = castTo gTypeNamedNodeMap "NamedNodeMap" + +gTypeNamedNodeMap :: GType +gTypeNamedNodeMap = + {# call fun unsafe webkit_dom_named_node_map_get_type #} + +-- ****************************************************************** Navigator + +{#pointer *WebKitDOMNavigator as Navigator foreign newtype #} deriving (Eq,Ord) + +mkNavigator = (Navigator, objectUnrefFromMainloop) +unNavigator (Navigator o) = o + +class GObjectClass o => NavigatorClass o +toNavigator :: NavigatorClass o => o -> Navigator +toNavigator = unsafeCastGObject . toGObject + +instance NavigatorClass Navigator +instance GObjectClass Navigator where + toGObject = GObject . castForeignPtr . unNavigator + unsafeCastGObject = Navigator . castForeignPtr . unGObject + +castToNavigator :: GObjectClass obj => obj -> Navigator +castToNavigator = castTo gTypeNavigator "Navigator" + +gTypeNavigator :: GType +gTypeNavigator = + {# call fun unsafe webkit_dom_navigator_get_type #} + +-- ***************************************************************** NodeFilter + +{#pointer *WebKitDOMNodeFilter as NodeFilter foreign newtype #} deriving (Eq,Ord) + +mkNodeFilter = (NodeFilter, objectUnrefFromMainloop) +unNodeFilter (NodeFilter o) = o + +class GObjectClass o => NodeFilterClass o +toNodeFilter :: NodeFilterClass o => o -> NodeFilter +toNodeFilter = unsafeCastGObject . toGObject + +instance NodeFilterClass NodeFilter +instance GObjectClass NodeFilter where + toGObject = GObject . castForeignPtr . unNodeFilter + unsafeCastGObject = NodeFilter . castForeignPtr . unGObject + +castToNodeFilter :: GObjectClass obj => obj -> NodeFilter +castToNodeFilter = castTo gTypeNodeFilter "NodeFilter" + +gTypeNodeFilter :: GType +gTypeNodeFilter = + {# call fun unsafe webkit_dom_node_filter_get_type #} + +-- *************************************************************** NodeIterator + +{#pointer *WebKitDOMNodeIterator as NodeIterator foreign newtype #} deriving (Eq,Ord) + +mkNodeIterator = (NodeIterator, objectUnrefFromMainloop) +unNodeIterator (NodeIterator o) = o + +class GObjectClass o => NodeIteratorClass o +toNodeIterator :: NodeIteratorClass o => o -> NodeIterator +toNodeIterator = unsafeCastGObject . toGObject + +instance NodeIteratorClass NodeIterator +instance GObjectClass NodeIterator where + toGObject = GObject . castForeignPtr . unNodeIterator + unsafeCastGObject = NodeIterator . castForeignPtr . unGObject + +castToNodeIterator :: GObjectClass obj => obj -> NodeIterator +castToNodeIterator = castTo gTypeNodeIterator "NodeIterator" + +gTypeNodeIterator :: GType +gTypeNodeIterator = + {# call fun unsafe webkit_dom_node_iterator_get_type #} + +-- ******************************************************************* NodeList + +{#pointer *WebKitDOMNodeList as NodeList foreign newtype #} deriving (Eq,Ord) + +mkNodeList = (NodeList, objectUnrefFromMainloop) +unNodeList (NodeList o) = o + +class GObjectClass o => NodeListClass o +toNodeList :: NodeListClass o => o -> NodeList +toNodeList = unsafeCastGObject . toGObject + +instance NodeListClass NodeList +instance GObjectClass NodeList where + toGObject = GObject . castForeignPtr . unNodeList + unsafeCastGObject = NodeList . castForeignPtr . unGObject + +castToNodeList :: GObjectClass obj => obj -> NodeList +castToNodeList = castTo gTypeNodeList "NodeList" + +gTypeNodeList :: GType +gTypeNodeList = + {# call fun unsafe webkit_dom_node_list_get_type #} + +-- ****************************************************** PerformanceNavigation + +{#pointer *WebKitDOMPerformanceNavigation as PerformanceNavigation foreign newtype #} deriving (Eq,Ord) + +mkPerformanceNavigation = (PerformanceNavigation, objectUnrefFromMainloop) +unPerformanceNavigation (PerformanceNavigation o) = o + +class GObjectClass o => PerformanceNavigationClass o +toPerformanceNavigation :: PerformanceNavigationClass o => o -> PerformanceNavigation +toPerformanceNavigation = unsafeCastGObject . toGObject + +instance PerformanceNavigationClass PerformanceNavigation +instance GObjectClass PerformanceNavigation where + toGObject = GObject . castForeignPtr . unPerformanceNavigation + unsafeCastGObject = PerformanceNavigation . castForeignPtr . unGObject + +castToPerformanceNavigation :: GObjectClass obj => obj -> PerformanceNavigation +castToPerformanceNavigation = castTo gTypePerformanceNavigation "PerformanceNavigation" + +gTypePerformanceNavigation :: GType +gTypePerformanceNavigation = + {# call fun unsafe webkit_dom_performance_navigation_get_type #} + +-- ********************************************************** PerformanceTiming + +{#pointer *WebKitDOMPerformanceTiming as PerformanceTiming foreign newtype #} deriving (Eq,Ord) + +mkPerformanceTiming = (PerformanceTiming, objectUnrefFromMainloop) +unPerformanceTiming (PerformanceTiming o) = o + +class GObjectClass o => PerformanceTimingClass o +toPerformanceTiming :: PerformanceTimingClass o => o -> PerformanceTiming +toPerformanceTiming = unsafeCastGObject . toGObject + +instance PerformanceTimingClass PerformanceTiming +instance GObjectClass PerformanceTiming where + toGObject = GObject . castForeignPtr . unPerformanceTiming + unsafeCastGObject = PerformanceTiming . castForeignPtr . unGObject + +castToPerformanceTiming :: GObjectClass obj => obj -> PerformanceTiming +castToPerformanceTiming = castTo gTypePerformanceTiming "PerformanceTiming" + +gTypePerformanceTiming :: GType +gTypePerformanceTiming = + {# call fun unsafe webkit_dom_performance_timing_get_type #} + +-- ********************************************************************* Plugin + +{#pointer *WebKitDOMDOMPlugin as Plugin foreign newtype #} deriving (Eq,Ord) + +mkPlugin = (Plugin, objectUnrefFromMainloop) +unPlugin (Plugin o) = o + +class GObjectClass o => PluginClass o +toPlugin :: PluginClass o => o -> Plugin +toPlugin = unsafeCastGObject . toGObject + +instance PluginClass Plugin +instance GObjectClass Plugin where + toGObject = GObject . castForeignPtr . unPlugin + unsafeCastGObject = Plugin . castForeignPtr . unGObject + +castToPlugin :: GObjectClass obj => obj -> Plugin +castToPlugin = castTo gTypePlugin "Plugin" + +gTypePlugin :: GType +gTypePlugin = + {# call fun unsafe webkit_dom_dom_plugin_get_type #} + +-- **************************************************************** PluginArray + +{#pointer *WebKitDOMDOMPluginArray as PluginArray foreign newtype #} deriving (Eq,Ord) + +mkPluginArray = (PluginArray, objectUnrefFromMainloop) +unPluginArray (PluginArray o) = o + +class GObjectClass o => PluginArrayClass o +toPluginArray :: PluginArrayClass o => o -> PluginArray +toPluginArray = unsafeCastGObject . toGObject + +instance PluginArrayClass PluginArray +instance GObjectClass PluginArray where + toGObject = GObject . castForeignPtr . unPluginArray + unsafeCastGObject = PluginArray . castForeignPtr . unGObject + +castToPluginArray :: GObjectClass obj => obj -> PluginArray +castToPluginArray = castTo gTypePluginArray "PluginArray" + +gTypePluginArray :: GType +gTypePluginArray = + {# call fun unsafe webkit_dom_dom_plugin_array_get_type #} + +-- ********************************************************************** Range + +{#pointer *WebKitDOMRange as Range foreign newtype #} deriving (Eq,Ord) + +mkRange = (Range, objectUnrefFromMainloop) +unRange (Range o) = o + +class GObjectClass o => RangeClass o +toRange :: RangeClass o => o -> Range +toRange = unsafeCastGObject . toGObject + +instance RangeClass Range +instance GObjectClass Range where + toGObject = GObject . castForeignPtr . unRange + unsafeCastGObject = Range . castForeignPtr . unGObject + +castToRange :: GObjectClass obj => obj -> Range +castToRange = castTo gTypeRange "Range" + +gTypeRange :: GType +gTypeRange = + {# call fun unsafe webkit_dom_range_get_type #} + +-- ********************************************************************* Screen + +{#pointer *WebKitDOMScreen as Screen foreign newtype #} deriving (Eq,Ord) + +mkScreen = (Screen, objectUnrefFromMainloop) +unScreen (Screen o) = o + +class GObjectClass o => ScreenClass o +toScreen :: ScreenClass o => o -> Screen +toScreen = unsafeCastGObject . toGObject + +instance ScreenClass Screen +instance GObjectClass Screen where + toGObject = GObject . castForeignPtr . unScreen + unsafeCastGObject = Screen . castForeignPtr . unGObject + +castToScreen :: GObjectClass obj => obj -> Screen +castToScreen = castTo gTypeScreen "Screen" + +gTypeScreen :: GType +gTypeScreen = + {# call fun unsafe webkit_dom_screen_get_type #} + +-- ************************************************************* SecurityPolicy + +{#pointer *WebKitDOMDOMSecurityPolicy as SecurityPolicy foreign newtype #} deriving (Eq,Ord) + +mkSecurityPolicy = (SecurityPolicy, objectUnrefFromMainloop) +unSecurityPolicy (SecurityPolicy o) = o + +class GObjectClass o => SecurityPolicyClass o +toSecurityPolicy :: SecurityPolicyClass o => o -> SecurityPolicy +toSecurityPolicy = unsafeCastGObject . toGObject + +instance SecurityPolicyClass SecurityPolicy +instance GObjectClass SecurityPolicy where + toGObject = GObject . castForeignPtr . unSecurityPolicy + unsafeCastGObject = SecurityPolicy . castForeignPtr . unGObject + +castToSecurityPolicy :: GObjectClass obj => obj -> SecurityPolicy +castToSecurityPolicy = castTo gTypeSecurityPolicy "SecurityPolicy" + +gTypeSecurityPolicy :: GType +gTypeSecurityPolicy = + {# call fun unsafe webkit_dom_dom_security_policy_get_type #} + +-- ****************************************************************** Selection + +{#pointer *WebKitDOMDOMSelection as Selection foreign newtype #} deriving (Eq,Ord) + +mkSelection = (Selection, objectUnrefFromMainloop) +unSelection (Selection o) = o + +class GObjectClass o => SelectionClass o +toSelection :: SelectionClass o => o -> Selection +toSelection = unsafeCastGObject . toGObject + +instance SelectionClass Selection +instance GObjectClass Selection where + toGObject = GObject . castForeignPtr . unSelection + unsafeCastGObject = Selection . castForeignPtr . unGObject + +castToSelection :: GObjectClass obj => obj -> Selection +castToSelection = castTo gTypeSelection "Selection" + +gTypeSelection :: GType +gTypeSelection = + {# call fun unsafe webkit_dom_dom_selection_get_type #} + +-- ******************************************************************** Storage + +{#pointer *WebKitDOMStorage as Storage foreign newtype #} deriving (Eq,Ord) + +mkStorage = (Storage, objectUnrefFromMainloop) +unStorage (Storage o) = o + +class GObjectClass o => StorageClass o +toStorage :: StorageClass o => o -> Storage +toStorage = unsafeCastGObject . toGObject + +instance StorageClass Storage +instance GObjectClass Storage where + toGObject = GObject . castForeignPtr . unStorage + unsafeCastGObject = Storage . castForeignPtr . unGObject + +castToStorage :: GObjectClass obj => obj -> Storage +castToStorage = castTo gTypeStorage "Storage" + +gTypeStorage :: GType +gTypeStorage = + {# call fun unsafe webkit_dom_storage_get_type #} + +-- **************************************************************** StorageInfo + +{#pointer *WebKitDOMStorageInfo as StorageInfo foreign newtype #} deriving (Eq,Ord) + +mkStorageInfo = (StorageInfo, objectUnrefFromMainloop) +unStorageInfo (StorageInfo o) = o + +class GObjectClass o => StorageInfoClass o +toStorageInfo :: StorageInfoClass o => o -> StorageInfo +toStorageInfo = unsafeCastGObject . toGObject + +instance StorageInfoClass StorageInfo +instance GObjectClass StorageInfo where + toGObject = GObject . castForeignPtr . unStorageInfo + unsafeCastGObject = StorageInfo . castForeignPtr . unGObject + +castToStorageInfo :: GObjectClass obj => obj -> StorageInfo +castToStorageInfo = castTo gTypeStorageInfo "StorageInfo" + +gTypeStorageInfo :: GType +gTypeStorageInfo = + {# call fun unsafe webkit_dom_storage_info_get_type #} + +-- *************************************************************** StorageQuota + +{#pointer *WebKitDOMStorageQuota as StorageQuota foreign newtype #} deriving (Eq,Ord) + +mkStorageQuota = (StorageQuota, objectUnrefFromMainloop) +unStorageQuota (StorageQuota o) = o + +class GObjectClass o => StorageQuotaClass o +toStorageQuota :: StorageQuotaClass o => o -> StorageQuota +toStorageQuota = unsafeCastGObject . toGObject + +instance StorageQuotaClass StorageQuota +instance GObjectClass StorageQuota where + toGObject = GObject . castForeignPtr . unStorageQuota + unsafeCastGObject = StorageQuota . castForeignPtr . unGObject + +castToStorageQuota :: GObjectClass obj => obj -> StorageQuota +castToStorageQuota = castTo gTypeStorageQuota "StorageQuota" + +gTypeStorageQuota :: GType +gTypeStorageQuota = + {# call fun unsafe webkit_dom_storage_quota_get_type #} + +-- ***************************************************************** StyleMedia + +{#pointer *WebKitDOMStyleMedia as StyleMedia foreign newtype #} deriving (Eq,Ord) + +mkStyleMedia = (StyleMedia, objectUnrefFromMainloop) +unStyleMedia (StyleMedia o) = o + +class GObjectClass o => StyleMediaClass o +toStyleMedia :: StyleMediaClass o => o -> StyleMedia +toStyleMedia = unsafeCastGObject . toGObject + +instance StyleMediaClass StyleMedia +instance GObjectClass StyleMedia where + toGObject = GObject . castForeignPtr . unStyleMedia + unsafeCastGObject = StyleMedia . castForeignPtr . unGObject + +castToStyleMedia :: GObjectClass obj => obj -> StyleMedia +castToStyleMedia = castTo gTypeStyleMedia "StyleMedia" + +gTypeStyleMedia :: GType +gTypeStyleMedia = + {# call fun unsafe webkit_dom_style_media_get_type #} + +-- ***************************************************************** StyleSheet + +{#pointer *WebKitDOMStyleSheet as StyleSheet foreign newtype #} deriving (Eq,Ord) + +mkStyleSheet = (StyleSheet, objectUnrefFromMainloop) +unStyleSheet (StyleSheet o) = o + +class GObjectClass o => StyleSheetClass o +toStyleSheet :: StyleSheetClass o => o -> StyleSheet +toStyleSheet = unsafeCastGObject . toGObject + +instance StyleSheetClass StyleSheet +instance GObjectClass StyleSheet where + toGObject = GObject . castForeignPtr . unStyleSheet + unsafeCastGObject = StyleSheet . castForeignPtr . unGObject + +castToStyleSheet :: GObjectClass obj => obj -> StyleSheet +castToStyleSheet = castTo gTypeStyleSheet "StyleSheet" + +gTypeStyleSheet :: GType +gTypeStyleSheet = + {# call fun unsafe webkit_dom_style_sheet_get_type #} + +-- ************************************************************** CSSStyleSheet + +{#pointer *WebKitDOMCSSStyleSheet as CSSStyleSheet foreign newtype #} deriving (Eq,Ord) + +mkCSSStyleSheet = (CSSStyleSheet, objectUnrefFromMainloop) +unCSSStyleSheet (CSSStyleSheet o) = o + +class StyleSheetClass o => CSSStyleSheetClass o +toCSSStyleSheet :: CSSStyleSheetClass o => o -> CSSStyleSheet +toCSSStyleSheet = unsafeCastGObject . toGObject + +instance CSSStyleSheetClass CSSStyleSheet +instance StyleSheetClass CSSStyleSheet +instance GObjectClass CSSStyleSheet where + toGObject = GObject . castForeignPtr . unCSSStyleSheet + unsafeCastGObject = CSSStyleSheet . castForeignPtr . unGObject + +castToCSSStyleSheet :: GObjectClass obj => obj -> CSSStyleSheet +castToCSSStyleSheet = castTo gTypeCSSStyleSheet "CSSStyleSheet" + +gTypeCSSStyleSheet :: GType +gTypeCSSStyleSheet = + {# call fun unsafe webkit_dom_css_style_sheet_get_type #} + +-- ************************************************************* StyleSheetList + +{#pointer *WebKitDOMStyleSheetList as StyleSheetList foreign newtype #} deriving (Eq,Ord) + +mkStyleSheetList = (StyleSheetList, objectUnrefFromMainloop) +unStyleSheetList (StyleSheetList o) = o + +class GObjectClass o => StyleSheetListClass o +toStyleSheetList :: StyleSheetListClass o => o -> StyleSheetList +toStyleSheetList = unsafeCastGObject . toGObject + +instance StyleSheetListClass StyleSheetList +instance GObjectClass StyleSheetList where + toGObject = GObject . castForeignPtr . unStyleSheetList + unsafeCastGObject = StyleSheetList . castForeignPtr . unGObject + +castToStyleSheetList :: GObjectClass obj => obj -> StyleSheetList +castToStyleSheetList = castTo gTypeStyleSheetList "StyleSheetList" + +gTypeStyleSheetList :: GType +gTypeStyleSheetList = + {# call fun unsafe webkit_dom_style_sheet_list_get_type #} + +-- *********************************************************** TextTrackCueList + +{#pointer *WebKitDOMTextTrackCueList as TextTrackCueList foreign newtype #} deriving (Eq,Ord) + +mkTextTrackCueList = (TextTrackCueList, objectUnrefFromMainloop) +unTextTrackCueList (TextTrackCueList o) = o + +class GObjectClass o => TextTrackCueListClass o +toTextTrackCueList :: TextTrackCueListClass o => o -> TextTrackCueList +toTextTrackCueList = unsafeCastGObject . toGObject + +instance TextTrackCueListClass TextTrackCueList +instance GObjectClass TextTrackCueList where + toGObject = GObject . castForeignPtr . unTextTrackCueList + unsafeCastGObject = TextTrackCueList . castForeignPtr . unGObject + +castToTextTrackCueList :: GObjectClass obj => obj -> TextTrackCueList +castToTextTrackCueList = castTo gTypeTextTrackCueList "TextTrackCueList" + +gTypeTextTrackCueList :: GType +gTypeTextTrackCueList = + {# call fun unsafe webkit_dom_text_track_cue_list_get_type #} + +-- ***************************************************************** TimeRanges + +{#pointer *WebKitDOMTimeRanges as TimeRanges foreign newtype #} deriving (Eq,Ord) + +mkTimeRanges = (TimeRanges, objectUnrefFromMainloop) +unTimeRanges (TimeRanges o) = o + +class GObjectClass o => TimeRangesClass o +toTimeRanges :: TimeRangesClass o => o -> TimeRanges +toTimeRanges = unsafeCastGObject . toGObject + +instance TimeRangesClass TimeRanges +instance GObjectClass TimeRanges where + toGObject = GObject . castForeignPtr . unTimeRanges + unsafeCastGObject = TimeRanges . castForeignPtr . unGObject + +castToTimeRanges :: GObjectClass obj => obj -> TimeRanges +castToTimeRanges = castTo gTypeTimeRanges "TimeRanges" + +gTypeTimeRanges :: GType +gTypeTimeRanges = + {# call fun unsafe webkit_dom_time_ranges_get_type #} + +-- ********************************************************************** Touch + +{#pointer *WebKitDOMTouch as Touch foreign newtype #} deriving (Eq,Ord) + +mkTouch = (Touch, objectUnrefFromMainloop) +unTouch (Touch o) = o + +class GObjectClass o => TouchClass o +toTouch :: TouchClass o => o -> Touch +toTouch = unsafeCastGObject . toGObject + +instance TouchClass Touch +instance GObjectClass Touch where + toGObject = GObject . castForeignPtr . unTouch + unsafeCastGObject = Touch . castForeignPtr . unGObject + +castToTouch :: GObjectClass obj => obj -> Touch +castToTouch = castTo gTypeTouch "Touch" + +gTypeTouch :: GType +gTypeTouch = + {# call fun unsafe webkit_dom_touch_get_type #} + +-- ***************************************************************** TreeWalker + +{#pointer *WebKitDOMTreeWalker as TreeWalker foreign newtype #} deriving (Eq,Ord) + +mkTreeWalker = (TreeWalker, objectUnrefFromMainloop) +unTreeWalker (TreeWalker o) = o + +class GObjectClass o => TreeWalkerClass o +toTreeWalker :: TreeWalkerClass o => o -> TreeWalker +toTreeWalker = unsafeCastGObject . toGObject + +instance TreeWalkerClass TreeWalker +instance GObjectClass TreeWalker where + toGObject = GObject . castForeignPtr . unTreeWalker + unsafeCastGObject = TreeWalker . castForeignPtr . unGObject + +castToTreeWalker :: GObjectClass obj => obj -> TreeWalker +castToTreeWalker = castTo gTypeTreeWalker "TreeWalker" + +gTypeTreeWalker :: GType +gTypeTreeWalker = + {# call fun unsafe webkit_dom_tree_walker_get_type #} + +-- ************************************************************** ValidityState + +{#pointer *WebKitDOMValidityState as ValidityState foreign newtype #} deriving (Eq,Ord) + +mkValidityState = (ValidityState, objectUnrefFromMainloop) +unValidityState (ValidityState o) = o + +class GObjectClass o => ValidityStateClass o +toValidityState :: ValidityStateClass o => o -> ValidityState +toValidityState = unsafeCastGObject . toGObject + +instance ValidityStateClass ValidityState +instance GObjectClass ValidityState where + toGObject = GObject . castForeignPtr . unValidityState + unsafeCastGObject = ValidityState . castForeignPtr . unGObject + +castToValidityState :: GObjectClass obj => obj -> ValidityState +castToValidityState = castTo gTypeValidityState "ValidityState" + +gTypeValidityState :: GType +gTypeValidityState = + {# call fun unsafe webkit_dom_validity_state_get_type #} + +-- ***************************************************************** VideoTrack + +{#pointer *WebKitDOMVideoTrack as VideoTrack foreign newtype #} deriving (Eq,Ord) + +mkVideoTrack = (VideoTrack, objectUnrefFromMainloop) +unVideoTrack (VideoTrack o) = o + +class GObjectClass o => VideoTrackClass o +toVideoTrack :: VideoTrackClass o => o -> VideoTrack +toVideoTrack = unsafeCastGObject . toGObject + +instance VideoTrackClass VideoTrack +instance GObjectClass VideoTrack where + toGObject = GObject . castForeignPtr . unVideoTrack + unsafeCastGObject = VideoTrack . castForeignPtr . unGObject + +castToVideoTrack :: GObjectClass obj => obj -> VideoTrack +castToVideoTrack = castTo gTypeVideoTrack "VideoTrack" + +gTypeVideoTrack :: GType +gTypeVideoTrack = + {# call fun unsafe webkit_dom_video_track_get_type #} + +-- **************************************************************** WebKitPoint + +{#pointer *WebKitDOMWebKitPoint as WebKitPoint foreign newtype #} deriving (Eq,Ord) + +mkWebKitPoint = (WebKitPoint, objectUnrefFromMainloop) +unWebKitPoint (WebKitPoint o) = o + +class GObjectClass o => WebKitPointClass o +toWebKitPoint :: WebKitPointClass o => o -> WebKitPoint +toWebKitPoint = unsafeCastGObject . toGObject + +instance WebKitPointClass WebKitPoint +instance GObjectClass WebKitPoint where + toGObject = GObject . castForeignPtr . unWebKitPoint + unsafeCastGObject = WebKitPoint . castForeignPtr . unGObject + +castToWebKitPoint :: GObjectClass obj => obj -> WebKitPoint +castToWebKitPoint = castTo gTypeWebKitPoint "WebKitPoint" + +gTypeWebKitPoint :: GType +gTypeWebKitPoint = + {# call fun unsafe webkit_dom_webkit_point_get_type #} + +-- ************************************************************ XPathExpression + +{#pointer *WebKitDOMXPathExpression as XPathExpression foreign newtype #} deriving (Eq,Ord) + +mkXPathExpression = (XPathExpression, objectUnrefFromMainloop) +unXPathExpression (XPathExpression o) = o + +class GObjectClass o => XPathExpressionClass o +toXPathExpression :: XPathExpressionClass o => o -> XPathExpression +toXPathExpression = unsafeCastGObject . toGObject + +instance XPathExpressionClass XPathExpression +instance GObjectClass XPathExpression where + toGObject = GObject . castForeignPtr . unXPathExpression + unsafeCastGObject = XPathExpression . castForeignPtr . unGObject + +castToXPathExpression :: GObjectClass obj => obj -> XPathExpression +castToXPathExpression = castTo gTypeXPathExpression "XPathExpression" + +gTypeXPathExpression :: GType +gTypeXPathExpression = + {# call fun unsafe webkit_dom_xpath_expression_get_type #} + +-- ************************************************************ XPathNSResolver + +{#pointer *WebKitDOMXPathNSResolver as XPathNSResolver foreign newtype #} deriving (Eq,Ord) + +mkXPathNSResolver = (XPathNSResolver, objectUnrefFromMainloop) +unXPathNSResolver (XPathNSResolver o) = o + +class GObjectClass o => XPathNSResolverClass o +toXPathNSResolver :: XPathNSResolverClass o => o -> XPathNSResolver +toXPathNSResolver = unsafeCastGObject . toGObject + +instance XPathNSResolverClass XPathNSResolver +instance GObjectClass XPathNSResolver where + toGObject = GObject . castForeignPtr . unXPathNSResolver + unsafeCastGObject = XPathNSResolver . castForeignPtr . unGObject + +castToXPathNSResolver :: GObjectClass obj => obj -> XPathNSResolver +castToXPathNSResolver = castTo gTypeXPathNSResolver "XPathNSResolver" + +gTypeXPathNSResolver :: GType +gTypeXPathNSResolver = + {# call fun unsafe webkit_dom_xpath_ns_resolver_get_type #} + +-- **************************************************************** XPathResult + +{#pointer *WebKitDOMXPathResult as XPathResult foreign newtype #} deriving (Eq,Ord) + +mkXPathResult = (XPathResult, objectUnrefFromMainloop) +unXPathResult (XPathResult o) = o + +class GObjectClass o => XPathResultClass o +toXPathResult :: XPathResultClass o => o -> XPathResult +toXPathResult = unsafeCastGObject . toGObject + +instance XPathResultClass XPathResult +instance GObjectClass XPathResult where + toGObject = GObject . castForeignPtr . unXPathResult + unsafeCastGObject = XPathResult . castForeignPtr . unGObject + +castToXPathResult :: GObjectClass obj => obj -> XPathResult +castToXPathResult = castTo gTypeXPathResult "XPathResult" + +gTypeXPathResult :: GType +gTypeXPathResult = + {# call fun unsafe webkit_dom_xpath_result_get_type #} diff --git a/Graphics/UI/Gtk/WebKit/WebDataSource.chs b/Graphics/UI/Gtk/WebKit/WebDataSource.chs --- a/Graphics/UI/Gtk/WebKit/WebDataSource.chs +++ b/Graphics/UI/Gtk/WebKit/WebDataSource.chs @@ -22,7 +22,7 @@ -- -- Note -- --- Function `webkit_web_data_source_get_data` haven't binding, +-- Function `webkit_web_data_source_get_data` haven't binding, -- no idea how to handle `GString` -- -- Access to the WebKit Web DataSource @@ -48,8 +48,8 @@ -- * Constructors webDataSourceNew, --- * Methods - -- webDataSourceGetData, +-- * Methods + webDataSourceGetData, webDataSourceGetEncoding, webDataSourceGetInitialRequest, webDataSourceGetMainResource, @@ -60,12 +60,14 @@ webDataSourceIsLoading, ) where -import Control.Monad (liftM) +import Control.Monad (liftM) +import Data.ByteString (ByteString) import System.Glib.FFI import System.Glib.UTFString import System.Glib.GList -import System.Glib.GError +import System.Glib.GString +import System.Glib.GError import Graphics.UI.Gtk.Gdk.Events {#import Graphics.UI.Gtk.Abstract.Object#} (makeNewObject) @@ -74,35 +76,32 @@ {#context lib="webkit" prefix ="webkit"#} --- | Creates a new 'WebDataSource' instance. +-- | Creates a new 'WebDataSource' instance. -- The URL of the 'WebDataSource' will be set to "about:blank". webDataSourceNew :: IO WebDataSource -webDataSourceNew = - wrapNewGObject mkWebDataSource $ {#call web_data_source_new#} +webDataSourceNew = + wrapNewGObject mkWebDataSource $ {#call web_data_source_new#} --- | Returns the raw data that represents the the frame's content.The data will be incomplete until the +-- | Returns the raw data that represents the the frame's content. The data will be incomplete until the -- data has finished loading. Returns 'Nothing' if the web frame hasn't loaded any data. Use -- @webkitWebDataSourceIsLoading@ to test if data source is in the process of loading. --- --- webDataSourceGetData :: WebDataSourceClass self => self --- -> IO (Maybe String) --- webDataSourceGetData ds = do --- ptr <- {#call webkit_web_data_source_get_data #} --- (toWebDataSource ds) --- if strPtr == nullPtr --- then return Nothing --- else liftM Just $ peekCStringLen (strPtr, strLen) +webDataSourceGetData :: WebDataSourceClass self => self + -> IO (Maybe ByteString) +webDataSourceGetData ds = do + gstr <- {#call webkit_web_data_source_get_data #} + (toWebDataSource ds) + readGStringByteString gstr -- | Returns the text encoding name as set in the 'WebView', or if not, the text encoding of the response. webDataSourceGetEncoding :: - WebDataSourceClass self => self - -> IO String -webDataSourceGetEncoding ds = - {#call web_data_source_get_encoding#} (toWebDataSource ds) >>= peekCString - --- | Returns a reference to the original request that was used to load the web content. + (WebDataSourceClass self, GlibString string) => self + -> IO string +webDataSourceGetEncoding ds = + {#call web_data_source_get_encoding#} (toWebDataSource ds) >>= peekUTFString + +-- | Returns a reference to the original request that was used to load the web content. -- The NetworkRequest returned by this method is the --- request prior to the "committed" load state. +-- request prior to the "committed" load state. -- See 'webDataSourceGetRequest' for getting the "committed" request. webDataSourceGetInitialRequest :: WebDataSourceClass self => self @@ -113,12 +112,12 @@ -- | Returns the main resource of the data_source webDataSourceGetMainResource :: WebDataSourceClass self => self - -> IO WebResource + -> IO WebResource webDataSourceGetMainResource ds = makeNewGObject mkWebResource $ {#call web_data_source_get_main_resource#} (toWebDataSource ds) - --- | Returns a NetworkRequest that was used to create this 'WebDataSource'. --- The NetworkRequest returned by this method is the request that was "committed", + +-- | Returns a NetworkRequest that was used to create this 'WebDataSource'. +-- The NetworkRequest returned by this method is the request that was "committed", -- and hence, different from the request you get from the 'webDataSourceGetInitialRequest' method. webDataSourceGetRequest :: WebDataSourceClass self => self @@ -129,21 +128,21 @@ -- | Gives you a List of 'WebResource' objects that compose the 'WebView' to which this 'WebDataSource' is attached. webDataSourceGetSubresources :: WebDataSourceClass self => self - -> IO [WebResource] + -> IO [WebResource] webDataSourceGetSubresources ds = do glist <- {#call web_data_source_get_subresources#} (toWebDataSource ds) resourcePtr <- fromGList glist mapM (makeNewGObject mkWebResource . return) resourcePtr --- | Return the unreachable URI of data_source. --- The 'dataSource' will have an unreachable URL --- if it was created using 'WebFrame''s +-- | Return the unreachable URI of data_source. +-- The 'dataSource' will have an unreachable URL +-- if it was created using 'WebFrame''s -- 'webFrameLoadAlternateHtmlString' method. webDataSourceGetUnreachableUri :: - WebDataSourceClass self => self - -> IO String + (WebDataSourceClass self, GlibString string) => self + -> IO string webDataSourceGetUnreachableUri ds = - {#call web_data_source_get_unreachable_uri#} (toWebDataSource ds) >>= peekCString + {#call web_data_source_get_unreachable_uri#} (toWebDataSource ds) >>= peekUTFString -- | Returns the 'WebFrame' that represents this data source webDataSourceGetWebFrame :: diff --git a/Graphics/UI/Gtk/WebKit/WebDatabase.chs b/Graphics/UI/Gtk/WebKit/WebDatabase.chs --- a/Graphics/UI/Gtk/WebKit/WebDatabase.chs +++ b/Graphics/UI/Gtk/WebKit/WebDatabase.chs @@ -28,19 +28,19 @@ -- | WebKitWebDatabase is a representation of a Web Database database. The proposed Web Database standard -- introduces support for SQL databases that web sites can create and access on a local computer -- through JavaScript. --- +-- -- To get access to all databases defined by a security origin, use -- 'securityOriginGetDatabases' Each database has a canonical name, as well as a user-friendly -- display name. --- +-- -- WebKit uses SQLite to create and access the local SQL databases. The location of a WebKitWebDatabase -- can be accessed wth 'webDatabaseGetFilename' You can configure the location of all -- databases with 'setDatabaseDirectoryPath'. --- +-- -- For each database the web site can define an estimated size which can be accessed with -- 'webDatabaseGetExpectedSize' The current size of the database in bytes is returned by -- 'webDatabaseGetSize'. --- +-- -- For more information refer to the Web Database specification proposal at -- http://dev.w3.org/html5/webdatabase @@ -48,7 +48,7 @@ WebDatabase, WebDatabaseClass, --- * Methods +-- * Methods webDatabaseGetDisplayName, webDatabaseGetExpectedSize, webDatabaseGetFilename, @@ -63,7 +63,7 @@ import System.Glib.FFI import System.Glib.UTFString import System.Glib.GList -import System.Glib.GError +import System.Glib.GError import Graphics.UI.Gtk.Gdk.Events {#import Graphics.UI.Gtk.Abstract.Object#} (makeNewObject) @@ -74,47 +74,47 @@ -- | Returns the name of the 'WebDatabase' as seen by the user. webDatabaseGetDisplayName :: - WebDatabaseClass self => self - -> IO String + (WebDatabaseClass self, GlibString string) => self + -> IO string webDatabaseGetDisplayName wd = - {#call web_database_get_display_name#} (toWebDatabase wd) >>= peekCString - + {#call web_database_get_display_name#} (toWebDatabase wd) >>= peekUTFString + -- | Returns the expected size of the Database in bytes as defined by the web author. The Web Database standard allows web authors to -- specify an expected size of the database to optimize the user experience. -webDatabaseGetExpectedSize :: +webDatabaseGetExpectedSize :: WebDatabaseClass self => self - -> IO Int + -> IO Int webDatabaseGetExpectedSize wd = liftM fromIntegral $ {#call web_database_get_expected_size#} (toWebDatabase wd) -- | Returns the absolute filename to the WebKitWebDatabase file on disk. webDatabaseGetFilename :: - WebDatabaseClass self => self - -> IO String -webDatabaseGetFilename wd = - {#call web_database_get_filename#} (toWebDatabase wd) >>= peekCString + (WebDatabaseClass self, GlibString string) => self + -> IO string +webDatabaseGetFilename wd = + {#call web_database_get_filename#} (toWebDatabase wd) >>= peekUTFString -- | Returns the canonical name of the 'WebDatabase'. webDatabaseGetName :: - WebDatabaseClass self => self - -> IO String -webDatabaseGetName wd = - {#call web_database_get_name#} (toWebDatabase wd) >>= peekCString + (WebDatabaseClass self, GlibString string) => self + -> IO string +webDatabaseGetName wd = + {#call web_database_get_name#} (toWebDatabase wd) >>= peekUTFString -- | Returns the security origin of the WebKitWebDatabase. -webDatabaseGetSecurityOrigin :: +webDatabaseGetSecurityOrigin :: WebDatabaseClass self => self - -> IO SecurityOrigin + -> IO SecurityOrigin webDatabaseGetSecurityOrigin wd = makeNewGObject mkSecurityOrigin $ {#call web_database_get_security_origin#} (toWebDatabase wd) --- | Returns the actual size of the 'WebDatabase' space on disk in bytes. +-- | Returns the actual size of the 'WebDatabase' space on disk in bytes. webDatabaseGetSize :: - WebDatabaseClass self => self + WebDatabaseClass self => self -> IO Int -webDatabaseGetSize wd = +webDatabaseGetSize wd = liftM fromIntegral $ {#call web_database_get_size#} (toWebDatabase wd) - + -- | Removes the 'WebDatabase' from its security origin and destroys all data stored in the database. webDatabaseRemove :: WebDatabaseClass self => self diff --git a/Graphics/UI/Gtk/WebKit/WebFrame.chs b/Graphics/UI/Gtk/WebKit/WebFrame.chs --- a/Graphics/UI/Gtk/WebKit/WebFrame.chs +++ b/Graphics/UI/Gtk/WebKit/WebFrame.chs @@ -5,7 +5,7 @@ -- Author : Cjacker Huang -- Copyright : (c) 2009 Cjacker Huang -- Copyright : (c) 2010 Andy Stewart --- +-- -- This library is free software; you can redistribute it and/or -- modify it under the terms of the GNU Lesser General Public -- License as published by the Free Software Foundation; either @@ -24,7 +24,7 @@ -- The content of a 'WebView' -- -- Note: --- Functon `webkit_web_frame_get_global_context` can't binding now, +-- Functon `webkit_web_frame_get_global_context` can't binding now, -- Because it need `JSGlobalContextRef` exist in JavaScriptCore. -- -- Function `webkit_web_frame_print_full` can't binding now, @@ -72,12 +72,13 @@ webFramePrint, ) where -import Control.Monad (liftM) +import Control.Monad (liftM) +import Data.ByteString (ByteString, useAsCString) import System.Glib.FFI import System.Glib.UTFString import System.Glib.GList -import System.Glib.GError +import System.Glib.GError import Graphics.UI.Gtk.Gdk.Events import Graphics.UI.Gtk.General.Enums @@ -98,209 +99,233 @@ -- | Create a new 'WebFrame' instance with the given @webview@. -- -- A 'WebFrame' contains the content of one URI. -webFrameNew :: +webFrameNew :: WebViewClass webview => webview -- ^ @webview@ - the given webview -> IO WebFrame -webFrameNew webview = +webFrameNew webview = wrapNewGObject mkWebFrame $ {#call web_frame_new#} (toWebView webview) -- | Return the 'WebView' that manages the given 'WebFrame'. -webFrameGetWebView :: +webFrameGetWebView :: WebFrameClass self => self -> IO WebView -webFrameGetWebView webframe = +webFrameGetWebView webframe = makeNewObject mkWebView $ liftM castPtr $ {#call web_frame_get_web_view#} (toWebFrame webframe) -- | Return the name of the given 'WebFrame'. -webFrameGetName :: - WebFrameClass self => self - -> IO (Maybe String) -- ^ the name string or @Nothing@ in case failed. -webFrameGetName webframe = - {#call web_frame_get_name#} (toWebFrame webframe) >>= maybePeek peekCString +webFrameGetName :: + (WebFrameClass self, GlibString string) => self + -> IO (Maybe string) -- ^ the name string or @Nothing@ in case failed. +webFrameGetName webframe = + {#call web_frame_get_name#} (toWebFrame webframe) >>= maybePeek peekUTFString #if WEBKIT_CHECK_VERSION (1,1,18) -- | Returns a WebKitNetworkResponse object representing the response that was given to the request for --- the given frame, or 'Nothing' if the frame was not created by a load. +-- the given frame, or 'Nothing' if the frame was not created by a load. -- -- * Since 1.1.18 webFrameGetNetworkResponse :: WebFrameClass self => self -> IO (Maybe NetworkResponse) webFrameGetNetworkResponse frame = - maybeNull (makeNewGObject mkNetworkResponse) $ + maybeNull (makeNewGObject mkNetworkResponse) $ {#call webkit_web_frame_get_network_response#} (toWebFrame frame) #endif -- | Return the title of the given 'WebFrame'. -webFrameGetTitle :: - WebFrameClass self => self - -> IO (Maybe String) -- ^ the title string or @Nothing@ in case failed. -webFrameGetTitle webframe = - {#call web_frame_get_title#} (toWebFrame webframe) >>= maybePeek peekCString +webFrameGetTitle :: + (WebFrameClass self, GlibString string) => self + -> IO (Maybe string) -- ^ the title string or @Nothing@ in case failed. +webFrameGetTitle webframe = + {#call web_frame_get_title#} (toWebFrame webframe) >>= maybePeek peekUTFString -- | Return the URI of the given 'WebFrame'. -webFrameGetUri :: - WebFrameClass self => self - -> IO (Maybe String) -- ^ the URI string or @Nothing@ in case failed. -webFrameGetUri webframe = - {#call web_frame_get_uri#} (toWebFrame webframe) >>= maybePeek peekCString +webFrameGetUri :: + (WebFrameClass self, GlibString string) => self + -> IO (Maybe string) -- ^ the URI string or @Nothing@ in case failed. +webFrameGetUri webframe = + {#call web_frame_get_uri#} (toWebFrame webframe) >>= maybePeek peekUTFString -- | Return the 'WebFrame''s parent frame if it has one, -- Otherwise return Nothing. -webFrameGetParent :: - WebFrameClass self => self +webFrameGetParent :: + WebFrameClass self => self -> IO (Maybe WebFrame) -- ^ a 'WebFrame' or @Nothing@ in case failed. -webFrameGetParent webframe = +webFrameGetParent webframe = maybeNull (makeNewGObject mkWebFrame) $ {#call web_frame_get_parent#} (toWebFrame webframe) -- | Determines the current status of the load. -- --- frame : a WebKitWebView --- +-- frame : a WebKitWebView +-- -- * Since 1.1.7 webFrameGetLoadStatus :: WebFrameClass self => self - -> IO LoadStatus + -> IO LoadStatus webFrameGetLoadStatus ls = liftM (toEnum . fromIntegral) $ {#call web_frame_get_load_status#} (toWebFrame ls) -- | Request loading of the specified URI string. -webFrameLoadUri :: - WebFrameClass self => self - -> String -- ^ @uri@ - an URI string. +webFrameLoadUri :: + (WebFrameClass self, GlibString string) => self + -> string -- ^ @uri@ - an URI string. -> IO () -webFrameLoadUri webframe uri = - withCString uri $ \uriPtr -> {#call web_frame_load_uri#} +webFrameLoadUri webframe uri = + withUTFString uri $ \uriPtr -> {#call web_frame_load_uri#} (toWebFrame webframe) uriPtr --- | Requests loading of the given @content@ +-- | Requests loading of the given @content@ +-- with the specified @mime_type@ and @base_uri@. +-- +-- If @mime_type@ is @Nothing@, \"text/html\" is assumed. +-- +-- If want control over the encoding use `webFrameLoadByteString` +webFrameLoadString :: + (WebFrameClass self, GlibString string) => self + -> string -- ^ @content@ - the content string to be loaded. + -> (Maybe string) -- ^ @mime_type@ - the MIME type or @Nothing@. + -> string -- ^ @base_uri@ - the base URI for relative locations. + -> IO() +webFrameLoadString webframe content mimetype baseuri = + withUTFString content $ \contentPtr -> + maybeWith withUTFString mimetype $ \mimetypePtr -> + withUTFString baseuri $ \baseuriPtr -> + {#call web_frame_load_string#} + (toWebFrame webframe) + contentPtr + mimetypePtr + nullPtr + baseuriPtr + +-- | Requests loading of the given @content@ -- with the specified @mime_type@, @encoding@ and @base_uri@. --- +-- -- If @mime_type@ is @Nothing@, \"text/html\" is assumed. -- -- If @encoding@ is @Nothing@, \"UTF-8\" is assumed. -webFrameLoadString :: - WebFrameClass self => self - -> String -- ^ @content@ - the content string to be loaded. - -> (Maybe String) -- ^ @mime_type@ - the MIME type or @Nothing@. - -> (Maybe String) -- ^ @encoding@ - the encoding or @Nothing@. - -> String -- ^ @base_uri@ - the base URI for relative locations. +webFrameLoadByteString :: + (WebFrameClass self, GlibString string) => self + -> ByteString -- ^ @content@ - the content string to be loaded. + -> (Maybe string) -- ^ @mime_type@ - the MIME type or @Nothing@. + -> (Maybe string) -- ^ @encoding@ - the encoding or @Nothing@. + -> string -- ^ @base_uri@ - the base URI for relative locations. -> IO() -webFrameLoadString webframe content mimetype encoding baseuri = - withCString content $ \contentPtr -> - maybeWith withCString mimetype $ \mimetypePtr -> - maybeWith withCString encoding $ \encodingPtr -> - withCString baseuri $ \baseuriPtr -> - {#call web_frame_load_string#} - (toWebFrame webframe) - contentPtr - mimetypePtr - encodingPtr +webFrameLoadByteString webframe content mimetype encoding baseuri = + useAsCString content $ \contentPtr -> + maybeWith withUTFString mimetype $ \mimetypePtr -> + maybeWith withUTFString encoding $ \encodingPtr -> + withUTFString baseuri $ \baseuriPtr -> + {#call web_frame_load_string#} + (toWebFrame webframe) + contentPtr + mimetypePtr + encodingPtr baseuriPtr + -- |Request loading of an alternate content for a URL that is unreachable. -- -- Using this method will preserve the back-forward list. --- The URI passed in @base_uri@ has to be an absolute URI. -webFrameLoadAlternateString :: - WebFrameClass self => self - -> String -- ^ @content@ - the alternate content to display +-- The URI passed in @base_uri@ has to be an absolute URI. +webFrameLoadAlternateString :: + (WebFrameClass self, GlibString string) => self + -> string -- ^ @content@ - the alternate content to display -- as the main page of the frame - -> String -- ^ @base_uri@ - the base URI for relative locations. - -> String -- ^ @unreachable_url@ - the URL for the alternate page content. + -> string -- ^ @base_uri@ - the base URI for relative locations. + -> string -- ^ @unreachable_url@ - the URL for the alternate page content. -> IO() -webFrameLoadAlternateString webframe content baseurl unreachableurl = - withCString content $ \contentPtr -> - withCString baseurl $ \baseurlPtr -> - withCString unreachableurl $ \unreachableurlPtr -> +webFrameLoadAlternateString webframe content baseurl unreachableurl = + withUTFString content $ \contentPtr -> + withUTFString baseurl $ \baseurlPtr -> + withUTFString unreachableurl $ \unreachableurlPtr -> {#call web_frame_load_alternate_string#} - (toWebFrame webframe) + (toWebFrame webframe) contentPtr baseurlPtr unreachableurlPtr -- | Connects to a given URI by initiating an asynchronous client request. -- --- Creates a provisional data source that will transition to a committed data source once any data has been received. --- Use 'webFrameStopLoading' to stop the load. +-- Creates a provisional data source that will transition to a committed data source once any data has been received. +-- Use 'webFrameStopLoading' to stop the load. -- This function is typically invoked on the main frame. -webFrameLoadRequest :: +webFrameLoadRequest :: (WebFrameClass self, NetworkRequestClass requ) => self -> requ -> IO () webFrameLoadRequest webframe request = - {#call web_frame_load_request#} (toWebFrame webframe) (toNetworkRequest request) + {#call web_frame_load_request#} (toWebFrame webframe) (toNetworkRequest request) -- | Stops and pending loads on the given data source and those of its children. -webFrameStopLoading :: +webFrameStopLoading :: WebFrameClass self => self -> IO() -webFrameStopLoading webframe = +webFrameStopLoading webframe = {#call web_frame_stop_loading#} (toWebFrame webframe) -- |Reloads the initial request. -webFrameReload :: +webFrameReload :: WebFrameClass self => self -> IO() -webFrameReload webframe = +webFrameReload webframe = {#call web_frame_reload#} (toWebFrame webframe) --- |Return the 'WebFrame' associated with the given name +-- |Return the 'WebFrame' associated with the given name -- or @Nothing@ in case none if found --- --- For pre-defined names, return the given webframe if name is -webFrameFindFrame:: - WebFrameClass self => self - -> String -- ^ @name@ - the name of the frame to be found. +-- +-- For pre-defined names, return the given webframe if name is +webFrameFindFrame:: + (WebFrameClass self, GlibString string) => self + -> string -- ^ @name@ - the name of the frame to be found. -> IO (Maybe WebFrame) -webFrameFindFrame webframe name = - withCString name $ \namePtr -> - maybeNull (makeNewGObject mkWebFrame) $ +webFrameFindFrame webframe name = + withUTFString name $ \namePtr -> + maybeNull (makeNewGObject mkWebFrame) $ {#call web_frame_find_frame#} (toWebFrame webframe) namePtr -- | Returns the committed data source. -webFrameGetDataSource :: +webFrameGetDataSource :: WebFrameClass self => self -> IO WebDataSource webFrameGetDataSource webframe = makeNewGObject mkWebDataSource $ {#call web_frame_get_data_source#} (toWebFrame webframe) -- | Return the policy of horizontal scrollbar. -webFrameGetHorizontalScrollbarPolicy :: +webFrameGetHorizontalScrollbarPolicy :: WebFrameClass self => self - -> IO PolicyType -webFrameGetHorizontalScrollbarPolicy webframe = + -> IO PolicyType +webFrameGetHorizontalScrollbarPolicy webframe = liftM (toEnum.fromIntegral) $ {#call web_frame_get_horizontal_scrollbar_policy#} (toWebFrame webframe) - + -- | Return the policy of vertical scrollbar. -webFrameGetVerticalScrollbarPolicy :: +webFrameGetVerticalScrollbarPolicy :: WebFrameClass self => self - -> IO PolicyType -webFrameGetVerticalScrollbarPolicy webframe = + -> IO PolicyType +webFrameGetVerticalScrollbarPolicy webframe = liftM (toEnum.fromIntegral) $ {#call web_frame_get_vertical_scrollbar_policy#} (toWebFrame webframe) --- | You use the 'webFrameLoadRequest' method to initiate a request that creates a provisional data source. --- The provisional data source will transition to a committed data source once any data has been received. +-- | You use the 'webFrameLoadRequest' method to initiate a request that creates a provisional data source. +-- The provisional data source will transition to a committed data source once any data has been received. -- Use 'webFrameGetDataSource' to get the committed data source. -webFrameGetProvisionalDataSource :: +webFrameGetProvisionalDataSource :: WebFrameClass self => self - -> IO WebDataSource + -> IO WebDataSource webFrameGetProvisionalDataSource webframe = makeNewGObject mkWebDataSource $ {#call web_frame_get_provisional_data_source#} (toWebFrame webframe) -- | Returns the frame's security origin. webFrameGetSecurityOrigin :: WebFrameClass self => self - -> IO SecurityOrigin -webFrameGetSecurityOrigin webframe = + -> IO SecurityOrigin +webFrameGetSecurityOrigin webframe = makeNewGObject mkSecurityOrigin $ {#call web_frame_get_security_origin#} (toWebFrame webframe) -- |Prints the given 'WebFrame'. -- --- by presenting a print dialog to the user. -webFramePrint:: +-- by presenting a print dialog to the user. +webFramePrint:: WebFrameClass self => self -> IO() -webFramePrint webframe = +webFramePrint webframe = {#call web_frame_print#} (toWebFrame webframe) diff --git a/Graphics/UI/Gtk/WebKit/WebHistoryItem.chs b/Graphics/UI/Gtk/WebKit/WebHistoryItem.chs --- a/Graphics/UI/Gtk/WebKit/WebHistoryItem.chs +++ b/Graphics/UI/Gtk/WebKit/WebHistoryItem.chs @@ -62,8 +62,8 @@ import System.Glib.FFI import System.Glib.UTFString import System.Glib.GList -import System.Glib.GError -import System.Glib.Attributes +import System.Glib.GError +import System.Glib.Attributes as G import Graphics.UI.Gtk.Gdk.Events {#import Graphics.UI.Gtk.Abstract.Object#} (makeNewObject) @@ -79,123 +79,124 @@ -- | Create a new 'WebHistoryItem' instance. -- --- A history item consists out of a title and a uri, +-- A history item consists out of a title and a uri, -- it can be part of the WebBackForwardList and the global history. -- -- The global history is used for coloring the links of visited sites. --- 'WebHistoryItem' constructed with 'webHistoryItemNew' are +-- 'WebHistoryItem' constructed with 'webHistoryItemNew' are -- automatically added to the global history. webHistoryItemNew :: IO WebHistoryItem -webHistoryItemNew = +webHistoryItemNew = wrapNewGObject mkWebHistoryItem $ {#call web_history_item_new#} -- | Create a new 'WebHistoryItem' instance with the given @uri@ and @title@. --- --- 'WebHistoryItem' constructed with 'webHistoryItemNewWithData' are +-- +-- 'WebHistoryItem' constructed with 'webHistoryItemNewWithData' are -- automatically added to the global history. -webHistoryItemNewWithData :: - String -- ^ @uri@ - the uri of the item - -> String -- ^ @title@ - the title of the item +webHistoryItemNewWithData :: + GlibString string + => string -- ^ @uri@ - the uri of the item + -> string -- ^ @title@ - the title of the item -> IO WebHistoryItem -webHistoryItemNewWithData uri title = - withCString uri $ \uriPtr -> - withCString title $ \titlePtr -> +webHistoryItemNewWithData uri title = + withUTFString uri $ \uriPtr -> + withUTFString title $ \titlePtr -> wrapNewGObject mkWebHistoryItem $ - {#call web_history_item_new_with_data#} - uriPtr + {#call web_history_item_new_with_data#} + uriPtr titlePtr -- | Return the title of 'WebHistoryItem'. -webHistoryItemGetTitle :: - WebHistoryItemClass self => self - -> IO (Maybe String) -- ^ the title or @Nothing@ in case failed. -webHistoryItemGetTitle webhistoryitem = - {#call web_history_item_get_title#} - (toWebHistoryItem webhistoryitem) >>= - maybePeek peekCString +webHistoryItemGetTitle :: + (WebHistoryItemClass self, GlibString string) => self + -> IO (Maybe string) -- ^ the title or @Nothing@ in case failed. +webHistoryItemGetTitle webhistoryitem = + {#call web_history_item_get_title#} + (toWebHistoryItem webhistoryitem) >>= + maybePeek peekUTFString -- | Return the alternate title of WebHistoryItem. -webHistoryItemGetAlternateTitle :: - WebHistoryItemClass self => self - -> IO (Maybe String) -- ^ the alternate title or @Nothing@ in case failed. -webHistoryItemGetAlternateTitle webhistoryitem = - {#call web_history_item_get_alternate_title#} - (toWebHistoryItem webhistoryitem) >>= - maybePeek peekCString +webHistoryItemGetAlternateTitle :: + (WebHistoryItemClass self, GlibString string) => self + -> IO (Maybe string) -- ^ the alternate title or @Nothing@ in case failed. +webHistoryItemGetAlternateTitle webhistoryitem = + {#call web_history_item_get_alternate_title#} + (toWebHistoryItem webhistoryitem) >>= + maybePeek peekUTFString -- | Set an alternate title for WebHistoryItem. -webHistoryItemSetAlternateTitle :: - WebHistoryItemClass self => self - -> (Maybe String) -- ^ @title@ - the alternate title for this history item. +webHistoryItemSetAlternateTitle :: + (WebHistoryItemClass self, GlibString string) => self + -> (Maybe string) -- ^ @title@ - the alternate title for this history item. -> IO() webHistoryItemSetAlternateTitle webhistoryitem title = - maybeWith withCString title $ \titlePtr -> - {#call web_history_item_set_alternate_title#} + maybeWith withUTFString title $ \titlePtr -> + {#call web_history_item_set_alternate_title#} (toWebHistoryItem webhistoryitem) titlePtr -- | Return the URI of WebHistoryItem. -webHistoryItemGetUri :: - WebHistoryItemClass self => self - -> IO (Maybe String) -- ^ the URI or @Nothing@ in case failed. -webHistoryItemGetUri webhistoryitem = - {#call web_history_item_get_uri#} - (toWebHistoryItem webhistoryitem) >>= - maybePeek peekCString +webHistoryItemGetUri :: + (WebHistoryItemClass self, GlibString string) => self + -> IO (Maybe string) -- ^ the URI or @Nothing@ in case failed. +webHistoryItemGetUri webhistoryitem = + {#call web_history_item_get_uri#} + (toWebHistoryItem webhistoryitem) >>= + maybePeek peekUTFString -- | Return the original URI of WebHistoryItem. -webHistoryItemGetOriginalUri :: - WebHistoryItemClass self => self - -> IO (Maybe String) -- ^ the URI or @Nothing@ in case failed -webHistoryItemGetOriginalUri webhistoryitem = - {#call web_history_item_get_original_uri#} - (toWebHistoryItem webhistoryitem) >>= - maybePeek peekCString +webHistoryItemGetOriginalUri :: + (WebHistoryItemClass self, GlibString string) => self + -> IO (Maybe string) -- ^ the URI or @Nothing@ in case failed +webHistoryItemGetOriginalUri webhistoryitem = + {#call web_history_item_get_original_uri#} + (toWebHistoryItem webhistoryitem) >>= + maybePeek peekUTFString -- | Return the last visited time of WebHistoryItem. -webHistoryItemGetLastVisitedTime :: - WebHistoryItemClass self => self +webHistoryItemGetLastVisitedTime :: + WebHistoryItemClass self => self -> IO Double -- ^ the last visited time of this history item. -webHistoryItemGetLastVisitedTime webhistoryitem = - liftM realToFrac $ - {#call web_history_item_get_last_visited_time#} +webHistoryItemGetLastVisitedTime webhistoryitem = + liftM realToFrac $ + {#call web_history_item_get_last_visited_time#} (toWebHistoryItem webhistoryitem) #if WEBKIT_CHECK_VERSION (1,1,18) -- | Makes a copy of the item for use with other WebView objects. -- --- * Since 1.1.18 +-- * Since 1.1.18 webHistoryItemCopy :: WebHistoryItemClass self => self -> IO WebHistoryItem webHistoryItemCopy webhistoryitem = - makeNewGObject mkWebHistoryItem $ + makeNewGObject mkWebHistoryItem $ {#call webkit_web_history_item_copy#} (toWebHistoryItem webhistoryitem) #endif -- | The title of the 'WebHistoryItem' -- -- Default value: @Nothing@ -webHistoryItemTitle :: (WebHistoryItemClass self) => ReadAttr self (Maybe String) +webHistoryItemTitle :: (WebHistoryItemClass self, GlibString string) => ReadAttr self (Maybe string) webHistoryItemTitle = readAttr webHistoryItemGetTitle -- | The alternate title of the history item. -- -- Default value: @Nothing@ -webHistoryItemAlternateTitle :: (WebHistoryItemClass self) => Attr self (Maybe String) +webHistoryItemAlternateTitle :: (WebHistoryItemClass self, GlibString string) => G.Attr self (Maybe string) webHistoryItemAlternateTitle = newAttr webHistoryItemGetAlternateTitle webHistoryItemSetAlternateTitle -- | The URI of the history item. -- -- Default value: @Nothing@ -webHistoryItemUri :: (WebHistoryItemClass self) => ReadAttr self (Maybe String) +webHistoryItemUri :: (WebHistoryItemClass self, GlibString string) => ReadAttr self (Maybe string) webHistoryItemUri = readAttr webHistoryItemGetUri -- | The original URI of the history item. -- -- Default value: @Nothing@ -webHistoryItemOriginalUri :: (WebHistoryItemClass self) => ReadAttr self (Maybe String) +webHistoryItemOriginalUri :: (WebHistoryItemClass self, GlibString string) => ReadAttr self (Maybe string) webHistoryItemOriginalUri = readAttr webHistoryItemGetOriginalUri -- | The time at which the history item was last visited. @@ -205,4 +206,4 @@ -- Default value: 0 webHistoryItemLastVisitedTime :: (WebHistoryItemClass self) => ReadAttr self Double webHistoryItemLastVisitedTime = readAttr webHistoryItemGetLastVisitedTime - + diff --git a/Graphics/UI/Gtk/WebKit/WebInspector.chs b/Graphics/UI/Gtk/WebKit/WebInspector.chs --- a/Graphics/UI/Gtk/WebKit/WebInspector.chs +++ b/Graphics/UI/Gtk/WebKit/WebInspector.chs @@ -28,7 +28,7 @@ -- | The WebKit Inspector is a graphical tool to inspect and change the content of a WebKitWebView. It -- also includes an interactive JavaScriptDebugger. Using this class one can get a 'Widget' which can -- be embedded into an application to show the inspector. --- +-- -- The inspector is available when the WebKitWebSettings of the WebKitWebView has set the -- 'enableDeveloperExtras' to true otherwise no inspector is available. @@ -45,7 +45,7 @@ webInspectorClose, #endif --- * Attribute +-- * Attribute webInspectorInspectedUri, webInspectorJSProfilingEnable, #if WEBKIT_CHECK_VERSION (1,1,17) @@ -67,8 +67,8 @@ import System.Glib.FFI import System.Glib.UTFString import System.Glib.GList -import System.Glib.GError -import System.Glib.Attributes +import System.Glib.GError +import System.Glib.Attributes as G import System.Glib.Properties import Graphics.UI.Gtk.Gdk.Events @@ -83,18 +83,18 @@ ------------------ -- | Obtains the URI that is currently being inspected -webInspectorGetInspectedUri :: - WebInspectorClass self => self - -> IO String -webInspectorGetInspectedUri inspector = - {#call web_inspector_get_inspected_uri#} (toWebInspector inspector) >>= peekCString +webInspectorGetInspectedUri :: + (WebInspectorClass self, GlibString string) => self + -> IO string +webInspectorGetInspectedUri inspector = + {#call web_inspector_get_inspected_uri#} (toWebInspector inspector) >>= peekUTFString --- | Obtains the 'WebView' that is used to render the 'WebInspector'. --- +-- | Obtains the 'WebView' that is used to render the 'WebInspector'. +-- -- The 'WebView' instance is created by the application, --- by handling the "inspect-web-view" signal. +-- by handling the "inspect-web-view" signal. -- This means that it may return @Nothing@ if the user hasn't inspected anything -webInspectorGetWebView :: +webInspectorGetWebView :: WebInspectorClass self => self -> IO (Maybe WebView) webInspectorGetWebView inspector = @@ -106,15 +106,15 @@ -- | Causes the Web Inspector to inspect the node that is located at the given coordinates of the -- widget. The coordinates should be relative to the WebKitWebView widget, not to the scrollable -- content, and may be obtained from a 'Event' directly. --- +-- -- This means x, and y being zero doesn't guarantee you will hit the left-most top corner of the -- content, since the contents may have been scrolled. --- +-- -- * Since 1.1.17 webInspectorInspectCoordinates :: WebInspectorClass self - => self -- ^ @webInspector@ the WebKitWebInspector that will do the inspection - -> Int -- ^ @x@ the X coordinate of the node to be inspected - -> Int -- ^ @y@ the Y coordinate of the node to be inspected + => self -- ^ @webInspector@ the WebKitWebInspector that will do the inspection + -> Int -- ^ @x@ the X coordinate of the node to be inspected + -> Int -- ^ @y@ the Y coordinate of the node to be inspected -> IO () webInspectorInspectCoordinates inspect x y = {#call web_inspector_inspect_coordinates#} @@ -140,26 +140,26 @@ -- * Attribute -- | The URI that is currently being inspected. -webInspectorInspectedUri :: (WebInspectorClass self) => ReadAttr self String +webInspectorInspectedUri :: (WebInspectorClass self, GlibString string) => ReadAttr self string webInspectorInspectedUri = readAttr webInspectorGetInspectedUri -- | This is enabling JavaScript profiling in the Inspector. This means that Console.profiles will return the profiles. -webInspectorJSProfilingEnable :: (WebInspectorClass self) => Attr self Bool +webInspectorJSProfilingEnable :: (WebInspectorClass self) => G.Attr self Bool webInspectorJSProfilingEnable = newAttrFromBoolProperty "javascript-profiling-enabled" #if WEBKIT_CHECK_VERSION (1,1,17) -- | This is enabling Timeline profiling in the Inspector. --- +-- -- Default value: 'False' --- +-- -- * Since 1.1.17 -webInspectorTimelineProfilingEnabled :: (WebInspectorClass self) => Attr self Bool +webInspectorTimelineProfilingEnabled :: (WebInspectorClass self) => G.Attr self Bool webInspectorTimelineProfilingEnabled = newAttrFromBoolProperty "timeline-profiling-enabled" #endif -- | The Web View that renders the Web Inspector itself. webInspectorWebView :: (WebInspectorClass self) => ReadAttr self WebView -webInspectorWebView = +webInspectorWebView = readAttrFromObjectProperty "web-view" {#call pure webkit_web_view_get_type#} @@ -173,33 +173,33 @@ -- | Emitted when the inspector should appear in a separate window. -- --- return True if the signal has been handled +-- return True if the signal has been handled detachWindow :: WebInspectorClass self => Signal self (IO Bool) detachWindow = Signal (connect_NONE__BOOL "detach_window") --- | Emitted when the inspector window should be closed. +-- | Emitted when the inspector window should be closed. -- -- return True if the signal is handled. closeWindow :: WebInspectorClass self => Signal self (IO Bool) closeWindow = Signal (connect_NONE__BOOL "close_window") --- | Emitted when the inspector window should be displayed. +-- | Emitted when the inspector window should be displayed. -- Notice that the window must have been created already by handling 'inspectWebView'. -- --- return True if the signal has been handled +-- return True if the signal has been handled showWindow :: WebInspectorClass self => Signal self (IO Bool) showWindow = Signal (connect_NONE__BOOL "show_window") --- | Emitted when the inspection is done. You should release your references on the inspector at this time. +-- | Emitted when the inspection is done. You should release your references on the inspector at this time. -- The inspected 'WebView' may no longer exist when this signal is emitted. finished :: WebInspectorClass self => Signal self (IO ()) finished = Signal (connect_NONE__NONE "finished") --- | Emitted when the user activates the 'inspect' context menu item to inspect a web view. --- The application which is interested in the inspector should create a window, +-- | Emitted when the user activates the 'inspect' context menu item to inspect a web view. +-- The application which is interested in the inspector should create a window, -- or otherwise add the 'WebView' it creates to an existing window. -- --- You don't need to handle the reference count of the 'WebView' instance you create; +-- You don't need to handle the reference count of the 'WebView' instance you create; -- the widget to which you add it will do that. inspectWebView :: WebInspectorClass self => Signal self (WebView -> IO WebView) inspectWebView = Signal (connect_OBJECT__OBJECTPTR "inspect_web_view") diff --git a/Graphics/UI/Gtk/WebKit/WebNavigationAction.chs b/Graphics/UI/Gtk/WebKit/WebNavigationAction.chs --- a/Graphics/UI/Gtk/WebKit/WebNavigationAction.chs +++ b/Graphics/UI/Gtk/WebKit/WebNavigationAction.chs @@ -36,7 +36,7 @@ -- * Enums NavigationReason(..), --- * Methods +-- * Methods webNavigationActionGetButton, webNavigationActionGetModifierState, webNavigationActionGetOriginalUri, @@ -51,7 +51,7 @@ import System.Glib.FFI import System.Glib.UTFString import System.Glib.GList -import System.Glib.GError +import System.Glib.GError import Graphics.UI.Gtk.Gdk.Events {#import Graphics.UI.Gtk.Abstract.Object#} (makeNewObject) @@ -62,57 +62,57 @@ -- * Enums -{#enum WebNavigationReason as NavigationReason {underscoreToCase}#} +{#enum WebNavigationReason as NavigationReason {underscoreToCase} deriving(Eq, Show) #} -- * Methods --- | Returns the DOM identifier for the mouse button used to click. --- DOM button values are 0, 1 and 2 for left, middle and right buttons. +-- | Returns the DOM identifier for the mouse button used to click. +-- DOM button values are 1, 2 and 3 for left, middle and right buttons. -- If the action was not initiated by a mouse click, returns -1. -webNavigationActionGetButton :: +webNavigationActionGetButton :: WebNavigationActionClass self => self -> IO Int -webNavigationActionGetButton action = +webNavigationActionGetButton action = liftM fromIntegral $ {#call web_navigation_action_get_button#} (toWebNavigationAction action) -- | Returns a bitmask with the the state of the modifier keys. -webNavigationActionGetModifierState :: +webNavigationActionGetModifierState :: WebNavigationActionClass self => self - -> IO Int -webNavigationActionGetModifierState action = + -> IO Int +webNavigationActionGetModifierState action = liftM fromIntegral $ {#call web_navigation_action_get_modifier_state#} (toWebNavigationAction action) - --- | Returns the URI that was originally requested. + +-- | Returns the URI that was originally requested. -- This may differ from the navigation target, for instance because of a redirect. -webNavigationActionGetOriginalUri :: - WebNavigationActionClass self => self - -> IO String -webNavigationActionGetOriginalUri action = - {#call web_navigation_action_get_original_uri#} (toWebNavigationAction action) >>= peekCString - +webNavigationActionGetOriginalUri :: + (WebNavigationActionClass self, GlibString string) => self + -> IO string +webNavigationActionGetOriginalUri action = + {#call web_navigation_action_get_original_uri#} (toWebNavigationAction action) >>= peekUTFString + -- | Returns the reason why WebKit is requesting a navigation. webNavigationActionGetReason :: WebNavigationActionClass self => self - -> IO NavigationReason -webNavigationActionGetReason action = + -> IO NavigationReason +webNavigationActionGetReason action = liftM (toEnum . fromIntegral) $ {#call web_navigation_action_get_reason#} (toWebNavigationAction action) -- | Returns the target frame of the action. -webNavigationActionGetTargetFrame :: - WebNavigationActionClass self => self - -> IO String -webNavigationActionGetTargetFrame action = - {#call web_navigation_action_get_target_frame#} (toWebNavigationAction action) >>= peekCString - --- | Sets the URI that was originally requested. +webNavigationActionGetTargetFrame :: + (WebNavigationActionClass self, GlibString string) => self + -> IO string +webNavigationActionGetTargetFrame action = + {#call web_navigation_action_get_target_frame#} (toWebNavigationAction action) >>= peekUTFString + +-- | Sets the URI that was originally requested. -- This may differ from the navigation target, for instance because of a redirect. webNavigationActionSetOriginalUri :: - WebNavigationActionClass self => self - -> String + (WebNavigationActionClass self, GlibString string) => self + -> string -> IO () webNavigationActionSetOriginalUri action uri = - withCString uri $ \uriPtr -> - {#call web_navigation_action_set_original_uri#} + withUTFString uri $ \uriPtr -> + {#call web_navigation_action_set_original_uri#} (toWebNavigationAction action) uriPtr @@ -123,4 +123,3 @@ -> IO () webNavigationActionSetReason action reason = {#call web_navigation_action_set_reason#} (toWebNavigationAction action) (fromIntegral (fromEnum reason)) - diff --git a/Graphics/UI/Gtk/WebKit/WebResource.chs b/Graphics/UI/Gtk/WebKit/WebResource.chs --- a/Graphics/UI/Gtk/WebKit/WebResource.chs +++ b/Graphics/UI/Gtk/WebKit/WebResource.chs @@ -40,19 +40,22 @@ -- * Constructors webResourceNew, --- * Methods +-- * Methods + webResourceGetData, webResourceGetEncoding, webResourceGetFrameName, webResourceGetMimeType, webResourceGetUri, ) where -import Control.Monad (liftM) +import Control.Monad (liftM) +import Data.ByteString (ByteString, useAsCStringLen) import System.Glib.FFI import System.Glib.UTFString import System.Glib.GList -import System.Glib.GError +import System.Glib.GString +import System.Glib.GError import Graphics.UI.Gtk.Gdk.Events {#import Graphics.UI.Gtk.Abstract.Object#} (makeNewObject) @@ -61,44 +64,49 @@ {#context lib="webkit" prefix ="webkit"#} --- | Returns a new WebKitWebResource. --- The @encoding@ can be empty. +-- | Returns a new WebKitWebResource. +-- The @encoding@ can be empty. -- The @frameName@ can be used if the resource represents contents of an -- entire HTML frame, otherwise pass empty. -webResourceNew :: String -> Int -> String -> String -> String -> String -> IO WebResource -webResourceNew resData size uri mimeType encoding frameName = - withCString resData $ \dataPtr -> - withCString uri $ \uriPtr -> - withCString mimeType $ \mimePtr -> - withCString encoding $ \encodingPtr -> - withCString frameName $ \framePtr -> - wrapNewGObject mkWebResource $ +webResourceNew :: GlibString string => ByteString -> string -> string -> string -> string -> IO WebResource +webResourceNew resData uri mimeType encoding frameName = + useAsCStringLen resData $ \(dataPtr, size) -> + withUTFString uri $ \uriPtr -> + withUTFString mimeType $ \mimePtr -> + withUTFString encoding $ \encodingPtr -> + withUTFString frameName $ \framePtr -> + wrapNewGObject mkWebResource $ {#call web_resource_new#} dataPtr (fromIntegral size) uriPtr mimePtr encodingPtr framePtr +-- | Returns the data of the WebResource. +webResourceGetData :: WebResourceClass self => self -> IO (Maybe ByteString) +webResourceGetData wr = + {#call web_resource_get_data#} (toWebResource wr) >>= readGStringByteString + -- | Get encoding. -webResourceGetEncoding :: - WebResourceClass self => self - -> IO (Maybe String) +webResourceGetEncoding :: + (WebResourceClass self, GlibString string) => self + -> IO (Maybe string) webResourceGetEncoding wr = - {#call web_resource_get_encoding#} (toWebResource wr) >>= maybePeek peekCString + {#call web_resource_get_encoding#} (toWebResource wr) >>= maybePeek peekUTFString -- | Get frame name. -webResourceGetFrameName :: - WebResourceClass self => self - -> IO (Maybe String) +webResourceGetFrameName :: + (WebResourceClass self, GlibString string) => self + -> IO (Maybe string) webResourceGetFrameName wr = - {#call web_resource_get_frame_name#} (toWebResource wr) >>= maybePeek peekCString + {#call web_resource_get_frame_name#} (toWebResource wr) >>= maybePeek peekUTFString -- | Get mime type. -webResourceGetMimeType :: - WebResourceClass self => self - -> IO (Maybe String) +webResourceGetMimeType :: + (WebResourceClass self, GlibString string) => self + -> IO (Maybe string) webResourceGetMimeType wr = - {#call web_resource_get_mime_type#} (toWebResource wr) >>= maybePeek peekCString + {#call web_resource_get_mime_type#} (toWebResource wr) >>= maybePeek peekUTFString -- | Get uri. -webResourceGetUri :: - WebResourceClass self => self - -> IO String +webResourceGetUri :: + (WebResourceClass self, GlibString string) => self + -> IO string webResourceGetUri wr = - {#call web_resource_get_uri#} (toWebResource wr) >>= peekCString + {#call web_resource_get_uri#} (toWebResource wr) >>= peekUTFString diff --git a/Graphics/UI/Gtk/WebKit/WebSettings.chs b/Graphics/UI/Gtk/WebKit/WebSettings.chs --- a/Graphics/UI/Gtk/WebKit/WebSettings.chs +++ b/Graphics/UI/Gtk/WebKit/WebSettings.chs @@ -100,9 +100,9 @@ import System.Glib.FFI import System.Glib.UTFString import System.Glib.GList -import System.Glib.GError +import System.Glib.GError import System.Glib.Properties -import System.Glib.Attributes +import System.Glib.Attributes as G import Graphics.UI.Gtk.Gdk.Events {#import Graphics.UI.Gtk.Abstract.Object#} (makeNewObject) @@ -117,158 +117,158 @@ -- | Create a new 'WebSettings' instance. --- +-- -- A 'WebSettings' can be applied to a 'WebView' --- to control the to be used text encoding, color, font size, +-- to control the to be used text encoding, color, font size, -- printing mode,script support, loading of images and various other things. webSettingsNew :: IO WebSettings -webSettingsNew = +webSettingsNew = wrapNewGObject mkWebSettings $ {#call web_settings_new#} -- | Copy an existing 'WebSettings' instance. -webSettingsCopy :: +webSettingsCopy :: WebSettingsClass self => self -> IO WebSettings -webSettingsCopy websettings = +webSettingsCopy websettings = constructNewGObject mkWebSettings $ {#call web_settings_copy#} (toWebSettings websettings) -- | Return the User-Agent string currently used. -webSettingsGetUserAgent :: - WebSettingsClass self => self - -> IO (Maybe String) -- ^ User-Agent string or @Nothing@ in case failed. -webSettingsGetUserAgent websettings = - {#call web_settings_get_user_agent#} (toWebSettings websettings) >>= maybePeek peekCString +webSettingsGetUserAgent :: + (WebSettingsClass self, GlibString string) => self + -> IO (Maybe string) -- ^ User-Agent string or @Nothing@ in case failed. +webSettingsGetUserAgent websettings = + {#call web_settings_get_user_agent#} (toWebSettings websettings) >>= maybePeek peekUTFString -- | Load images automatically -- -- Default value: True -webSettingsAutoLoadImages :: (WebSettingsClass self) => Attr self Bool +webSettingsAutoLoadImages :: (WebSettingsClass self) => G.Attr self Bool webSettingsAutoLoadImages = newAttrFromBoolProperty "auto-load-images" -- | Automatically shrink standalone images to fit -- -- Default value: True -webSettingsAutoShrinkImages :: (WebSettingsClass self) => Attr self Bool +webSettingsAutoShrinkImages :: (WebSettingsClass self) => G.Attr self Bool webSettingsAutoShrinkImages = newAttrFromBoolProperty "auto-shrink-images" -- | The default Cursive font family used to display text -- -- Default value "serif" -webSettingsCursiveFontFamily :: (WebSettingsClass self) => Attr self String +webSettingsCursiveFontFamily :: (WebSettingsClass self, GlibString string) => G.Attr self string webSettingsCursiveFontFamily = newAttrFromStringProperty "cursive-font-family" -- | The default encoding used to display text -- -- Default value "iso-8859-1" -webSettingsDefaultEncoding :: (WebSettingsClass self) => Attr self String +webSettingsDefaultEncoding :: (WebSettingsClass self, GlibString string) => G.Attr self string webSettingsDefaultEncoding = newAttrFromStringProperty "default-encoding" -- | The default font family used to display text -- -- Default value: "sans-serif" -webSettingsDefaultFontFamily :: (WebSettingsClass self) => Attr self String +webSettingsDefaultFontFamily :: (WebSettingsClass self, GlibString string) => G.Attr self string webSettingsDefaultFontFamily = newAttrFromStringProperty "default-font-family" -- | The default font size used to display text -- -- Default value: >=5 -webSettingsDefaultFontSize :: (WebSettingsClass self) => Attr self Int +webSettingsDefaultFontSize :: (WebSettingsClass self) => G.Attr self Int webSettingsDefaultFontSize = newAttrFromIntProperty "default-font-size" -- | The default font size used to display monospace text -- -- Allowed values: >= 5 --- +-- -- Default value: 10 -webSettingsDefaultMonospaceFontSize :: (WebSettingsClass self) => Attr self Int +webSettingsDefaultMonospaceFontSize :: (WebSettingsClass self) => G.Attr self Int webSettingsDefaultMonospaceFontSize = newAttrFromIntProperty "default-monospace-font-size" -- | This settings controls various editing behaviors -webSettingsEditingBehavior :: (WebSettingsClass self) => Attr self EditingBehavior +webSettingsEditingBehavior :: (WebSettingsClass self) => G.Attr self EditingBehavior webSettingsEditingBehavior = newAttrFromEnumProperty "editing-behavior" {#call pure unsafe webkit_editing_behavior_get_type#} -- | Whether to enable caret browsing mode. -webSettingsEnableCaretBrowsing :: (WebSettingsClass self) => Attr self Bool +webSettingsEnableCaretBrowsing :: (WebSettingsClass self) => G.Attr self Bool webSettingsEnableCaretBrowsing = newAttrFromBoolProperty "enable-caret-browsing" -- | Whether developer extensions should be enabled. -- -- This enables, for now, the 'WebInspector' -webSettingsEnableDeveloperExtras :: (WebSettingsClass self) => Attr self Bool +webSettingsEnableDeveloperExtras :: (WebSettingsClass self) => G.Attr self Bool webSettingsEnableDeveloperExtras = newAttrFromBoolProperty "enable-developer-extras" #if WEBKIT_CHECK_VERSION (1,1,16) -- | Whether to enable DOM paste. If set to 'True', document.execCommand("Paste") will correctly execute -- and paste content of the clipboard. --- +-- -- Default value: 'False' -- -- * Since 1.1.16 -webSettingsEnableDomPaste :: (WebSettingsClass self) => Attr self Bool +webSettingsEnableDomPaste :: (WebSettingsClass self) => G.Attr self Bool webSettingsEnableDomPaste = newAttrFromBoolProperty "enable-dom-paste" #endif -- | Whether to enable HTML5 client-side SQL database support. -webSettingsEnableHtml5Database :: (WebSettingsClass self) => Attr self Bool +webSettingsEnableHtml5Database :: (WebSettingsClass self) => G.Attr self Bool webSettingsEnableHtml5Database = newAttrFromBoolProperty "enable-html5-database" -- | Whether to enable HTML5 localStorage support. -webSettingsEnableHtml5LocalStorage :: (WebSettingsClass self) => Attr self Bool +webSettingsEnableHtml5LocalStorage :: (WebSettingsClass self) => G.Attr self Bool webSettingsEnableHtml5LocalStorage = newAttrFromBoolProperty "enable-html5-local-storage" -- | Whether to enable HTML5 offline web application cache support. -webSettingsEnableOfflineWebApplicationCache :: (WebSettingsClass self) => Attr self Bool +webSettingsEnableOfflineWebApplicationCache :: (WebSettingsClass self) => G.Attr self Bool webSettingsEnableOfflineWebApplicationCache = newAttrFromBoolProperty "enable-offline-web-application-cache" -- | Enable embedded plugin objects. -webSettingsEnablePlugins :: (WebSettingsClass self) => Attr self Bool +webSettingsEnablePlugins :: (WebSettingsClass self) => G.Attr self Bool webSettingsEnablePlugins = newAttrFromBoolProperty "enable-plugins" -- | Whether to enable private browsing mode. -webSettingsEnablePrivateBrowsing :: (WebSettingsClass self) => Attr self Bool +webSettingsEnablePrivateBrowsing :: (WebSettingsClass self) => G.Attr self Bool webSettingsEnablePrivateBrowsing = newAttrFromBoolProperty "enable-private-browsing" -- | Enable embedded scripting languages -webSettingsEnableScripts :: (WebSettingsClass self) => Attr self Bool +webSettingsEnableScripts :: (WebSettingsClass self) => G.Attr self Bool webSettingsEnableScripts = newAttrFromBoolProperty "enable-scripts" -- | Whether to enable speel checking while typing. -webSettingsEnableSpellChecking :: (WebSettingsClass self) => Attr self Bool +webSettingsEnableSpellChecking :: (WebSettingsClass self) => G.Attr self Bool webSettingsEnableSpellChecking = newAttrFromBoolProperty "enable-spell-checking" -- | Whether to allow files loaded through file:// URLs universal access to all pages. -webSettingsEnableUniversalAccessFromFileUris :: (WebSettingsClass self) => Attr self Bool +webSettingsEnableUniversalAccessFromFileUris :: (WebSettingsClass self) => G.Attr self Bool webSettingsEnableUniversalAccessFromFileUris = newAttrFromBoolProperty "enable-universal-access-from-file-uris" -- | Whether to enable the XSS Auditor. -- -- This feature filters some kinds of reflective XSS attacks on vulnerable web sites. -webSettingsEnableXssAuditor :: (WebSettingsClass self) => Attr self Bool +webSettingsEnableXssAuditor :: (WebSettingsClass self) => G.Attr self Bool webSettingsEnableXssAuditor = newAttrFromBoolProperty "enable-xss-auditor" -- | Enforce a resolution of 96 DPI. -webSettingsEnforce96Dpi :: (WebSettingsClass self) => Attr self Bool +webSettingsEnforce96Dpi :: (WebSettingsClass self) => G.Attr self Bool webSettingsEnforce96Dpi = newAttrFromBoolProperty "enforce-96-dpi" -- | The default Fantasy font family used to display text -webSettingsFantasyFontFamily :: (WebSettingsClass self) => Attr self String +webSettingsFantasyFontFamily :: (WebSettingsClass self, GlibString string) => G.Attr self string webSettingsFantasyFontFamily = newAttrFromStringProperty "fantasy-font-family" -- | Whether JavaScript can open popup windows automatically without user intervention. -webSettingsJSCanOpenWindowAuto :: (WebSettingsClass self) => Attr self Bool +webSettingsJSCanOpenWindowAuto :: (WebSettingsClass self) => G.Attr self Bool webSettingsJSCanOpenWindowAuto = newAttrFromBoolProperty "javascript-can-open-windows-automatically" -- | The minimum font size used to display text. --- +-- -- Allowed values: >=1 -- -- Default value: 5 -webSettingsMinimumFontSize :: (WebSettingsClass self) => Attr self Int +webSettingsMinimumFontSize :: (WebSettingsClass self) => G.Attr self Int webSettingsMinimumFontSize = newAttrFromIntProperty "minimum-font-size" -- | The minimum logical font size used to display text @@ -276,65 +276,65 @@ -- Allowed values: >=1 -- -- Default value: 5 -webSettingsMinimumLogicalFontSize :: (WebSettingsClass self) => Attr self Int +webSettingsMinimumLogicalFontSize :: (WebSettingsClass self) => G.Attr self Int webSettingsMinimumLogicalFontSize = newAttrFromIntProperty "minimum-logical-font-size" -- | The default font family used to display monospace text. --- +-- -- Default value: "monospace" -webSettingsMonospaceFontFamily :: (WebSettingsClass self) => Attr self String +webSettingsMonospaceFontFamily :: (WebSettingsClass self, GlibString string) => G.Attr self string webSettingsMonospaceFontFamily = newAttrFromStringProperty "monospace-font-family" -- | Whether background images should be printed -- -- Default value: True -webSettingsPrintBackgrounds :: (WebSettingsClass self) => Attr self Bool +webSettingsPrintBackgrounds :: (WebSettingsClass self) => G.Attr self Bool webSettingsPrintBackgrounds = newAttrFromBoolProperty "print-backgrounds" -- | Whether text areas are resizable -- -- Default value : True -webSettingsResizableTextAreas :: (WebSettingsClass self) => Attr self Bool +webSettingsResizableTextAreas :: (WebSettingsClass self) => G.Attr self Bool webSettingsResizableTextAreas = newAttrFromBoolProperty "resizable-text-areas" -- | The default Sans Serif font family used to display text --- +-- -- Default value "sans-serif" -webSettingsSansFontFamily :: (WebSettingsClass self) => Attr self String +webSettingsSansFontFamily :: (WebSettingsClass self, GlibString string) => G.Attr self string webSettingsSansFontFamily = newAttrFromStringProperty "sans-serif-font-family" -- | The default Serif font family used to display text -- -- Default value: "serif" -webSettingsSerifFontFamily :: (WebSettingsClass self) => Attr self String +webSettingsSerifFontFamily :: (WebSettingsClass self, GlibString string) => G.Attr self string webSettingsSerifFontFamily = newAttrFromStringProperty "serif-font-family" -- | The languages to be used for spell checking, separated by commas --- +-- -- The locale string typically is in the form lang_COUNTRY, --- where lang is an ISO-639 language code, and COUNTRY is an ISO-3166 country code. +-- where lang is an ISO-639 language code, and COUNTRY is an ISO-3166 country code. -- For instance, sv_FI for Swedish as written in Finland or pt_BR for Portuguese as written in Brazil. -- -- If no value is specified then the value returned by gtk_get_default_language will be used. -- -- Default value: @Nothing@ -webSettingsSpellCheckingLang :: (WebSettingsClass self) => Attr self (Maybe String) +webSettingsSpellCheckingLang :: (WebSettingsClass self, GlibString string) => G.Attr self (Maybe string) webSettingsSpellCheckingLang = newAttrFromMaybeStringProperty "spell-checking-languages" #if WEBKIT_CHECK_VERSION (1,1,17) -- | Whether the tab key cycles through elements on the page. --- +-- -- If flag is 'True', pressing the tab key will focus the next element in the @webView@. If flag is 'False', -- the @webView@ will interpret tab key presses as normal key presses. If the selected element is -- editable, the tab key will cause the insertion of a tab character. --- +-- -- Default value: 'True' -- -- * Since 1.1.17 -webSettingsTabKeyCyclesThroughElements :: (WebSettingsClass self) => Attr self Bool +webSettingsTabKeyCyclesThroughElements :: (WebSettingsClass self) => G.Attr self Bool webSettingsTabKeyCyclesThroughElements = newAttrFromBoolProperty "tab-key-cycles-through-elements" #endif @@ -343,11 +343,11 @@ -- menu. Turning this off will make WebKitGTK+ not emit the populate-popup signal. Notice that the -- default button press event handler may still handle right clicks for other reasons, such as in-page -- context menus, or right-clicks that are handled by the page itself. --- +-- -- Default value: 'True' --- +-- -- * Since 1.1.18 -webSettingsEnableDefaultContextMenu :: (WebSettingsClass self) => Attr self Bool +webSettingsEnableDefaultContextMenu :: (WebSettingsClass self) => G.Attr self Bool webSettingsEnableDefaultContextMenu = newAttrFromBoolProperty "enable-default-context-menu" -- | Enable or disable the page cache. Disabling the page cache is generally only useful for special @@ -356,30 +356,30 @@ -- memory-based traditional resource caches, its point is to make going back and forth between pages -- much faster. For details about the different types of caches and their purposes see: -- http://webkit.org/ blog/427/webkit-page-cache-i-the-basics/ --- +-- -- Default value: 'False' --- +-- -- * Since 1.1.18 -webSettingsEnablePageCache :: (WebSettingsClass self) => Attr self Bool +webSettingsEnablePageCache :: (WebSettingsClass self) => G.Attr self Bool webSettingsEnablePageCache = newAttrFromBoolProperty "enable-page-cache" #endif -- | The User-Agent string used by WebKit --- --- This will return a default User-Agent string if a custom string wasn't provided by the application. --- Setting this property to a NULL value or an empty string will result in +-- +-- This will return a default User-Agent string if a custom string wasn't provided by the application. +-- Setting this property to a NULL value or an empty string will result in -- the User-Agent string being reset to the default value. -- -- Default value: \"Mozilla/5.0 (X11; U; Linux x86_64; c) AppleWebKit/531.2+ (KHTML, like Gecko) Safari/531.2+\" -webSettingsUserAgent :: (WebSettingsClass self) => Attr self String +webSettingsUserAgent :: (WebSettingsClass self, GlibString string) => G.Attr self string webSettingsUserAgent = newAttrFromStringProperty "user-agent" -- | The URI of a stylesheet that is applied to every page. -- -- Default value: @Nothing@ -webSettingsUserStylesheetUri :: (WebSettingsClass self) => Attr self (Maybe String) +webSettingsUserStylesheetUri :: (WebSettingsClass self, GlibString string) => G.Attr self (Maybe string) webSettingsUserStylesheetUri = newAttrFromMaybeStringProperty "user-stylesheet-uri" -- | The value by which the zoom level is changed when zooming in or out @@ -387,13 +387,13 @@ -- Allowed values: >= 0 -- -- Default value: 0.1 -webSettingsZoomStep :: (WebSettingsClass self) => Attr self Float +webSettingsZoomStep :: (WebSettingsClass self) => G.Attr self Float webSettingsZoomStep = newAttrFromFloatProperty "zoom-step" - + -- | Enables the site-specific compatibility workarounds. -- -- Default value: False -webSettingsEnableSiteSpecificQuirks :: WebSettingsClass self => Attr self Bool +webSettingsEnableSiteSpecificQuirks :: WebSettingsClass self => G.Attr self Bool webSettingsEnableSiteSpecificQuirks = newAttrFromBoolProperty "enable-site-specific-quirks" #if WEBKIT_CHECK_VERSION (1,1,23) @@ -402,10 +402,10 @@ -- Down arrow keys. For example, if an user presses the Right key, heuristics determine whether there -- is an element he might be trying to reach towards the right, and if there are multiple elements, -- which element he probably wants. --- +-- -- Default value: 'False' --- +-- -- * Since 1.1.23 -webSettingsEnableSpatialNavigation :: WebSettingsClass self => Attr self Bool +webSettingsEnableSpatialNavigation :: WebSettingsClass self => G.Attr self Bool webSettingsEnableSpatialNavigation = newAttrFromBoolProperty "enable-spatial-navigation" #endif diff --git a/Graphics/UI/Gtk/WebKit/WebView.chs b/Graphics/UI/Gtk/WebKit/WebView.chs --- a/Graphics/UI/Gtk/WebKit/WebView.chs +++ b/Graphics/UI/Gtk/WebKit/WebView.chs @@ -1,1224 +1,1196 @@ -{-# LANGUAGE CPP #-} --- -*-haskell-*- ------------------------------------------------------------------------------ --- Module : Graphics.UI.Gtk.WebKit.WebView --- Author : Cjacker Huang --- Copyright : (c) 2009 Cjacker Huang --- Copyright : (c) 2010 Andy Stewart --- --- This library is free software; you can redistribute it and/or --- modify it under the terms of the GNU Lesser General Public --- License as published by the Free Software Foundation; either --- version 2.1 of the License, or (at your option) any later version. --- --- This library is distributed in the hope that it will be useful, --- but WITHOUT ANY WARRANTY; without even the implied warranty of --- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU --- Lesser General Public License for more details. --- --- | --- Maintainer : gtk2hs-users@lists.sourceforge.net --- Stability : provisional --- Portability : portable (depends on GHC) --- --- Note: --- --- Signal `window-object-cleared` can't bidning now, --- because it need JavaScriptCore that haven't binding. --- --- Signal `create-plugin-widget` can't binding now, --- no idea how to binding `GHaskellTable` --- --- --- TODO: --- --- `webViewGetHitTestResult` --- --- The central class of the WebKit ------------------------------------------------------------------------------ - -module Graphics.UI.Gtk.WebKit.WebView ( --- * Description --- | WebKitWebView is the central class of the WebKitGTK+ API. It is a 'Widget' implementing the --- scrolling interface which means you can embed in a 'ScrolledWindow'. It is responsible for managing --- the drawing of the content, forwarding of events. You can load any URI into the WebKitWebView or any --- kind of data string. With WebKitWebSettings you can control various aspects of the rendering and --- loading of the content. Each WebKitWebView has exactly one WebKitWebFrame as main frame. A --- WebKitWebFrame can have n children. - --- * Types - WebView, - WebViewClass, - --- * Enums - NavigationResponse(..), - TargetInfo(..), - LoadStatus(..), - --- * Constructors - webViewNew, - --- * Methods --- ** Load - webViewLoadUri, - webViewLoadHtmlString, - webViewLoadRequest, - webViewLoadString, --- ** Reload - webViewStopLoading, - webViewReload, - webViewReloadBypassCache, --- ** History - webViewCanGoBack, - webViewCanGoForward, - webViewGoBack, - webViewGoForward, - webViewGetBackForwardList, - webViewSetMaintainsBackForwardList, - webViewGoToBackForwardItem, - webViewCanGoBackOrForward, - webViewGoBackOrForward, --- ** Zoom - webViewGetZoomLevel, - webViewSetZoomLevel, - webViewZoomIn, - webViewZoomOut, - webViewGetFullContentZoom, - webViewSetFullContentZoom, --- ** Clipboard - webViewCanCutClipboard, - webViewCanCopyClipboard, - webViewCanPasteClipboard, - webViewCutClipboard, - webViewCopyClipboard, - webViewPasteClipboard, --- ** Undo/Redo - webViewCanRedo, - webViewCanUndo, - webViewRedo, - webViewUndo, --- ** Selection - webViewDeleteSelection, - webViewHasSelection, - webViewSelectAll, --- ** Encoding - webViewGetEncoding, - webViewSetCustomEncoding, - webViewGetCustomEncoding, --- ** Source Mode - webViewGetViewSourceMode, - webViewSetViewSourceMode, --- ** Transparent - webViewGetTransparent, - webViewSetTransparent, --- ** Target List - webViewGetCopyTargetList, - webViewGetPasteTargetList, --- ** Text Match - webViewMarkTextMatches, - webViewUnMarkTextMatches, - webViewSetHighlightTextMatches, --- ** Other - webViewExecuteScript, - - webViewCanShowMimeType, - webViewGetEditable, - webViewSetEditable, - webViewGetInspector, - - webViewGetProgress, - - webViewSearchText, - - webViewMoveCursor, - - webViewGetMainFrame, - webViewGetFocusedFrame, - - webViewSetWebSettings, - webViewGetWebSettings, - - webViewGetWindowFeatures, - -#if WEBKIT_CHECK_VERSION (1,1,18) - webViewGetIconUri, -#endif - - webViewGetTitle, - webViewGetUri, - --- * Attributes - webViewZoomLevel, - webViewFullContentZoom, - webViewEncoding, - webViewCustomEncoding, - webViewLoadStatus, - webViewProgress, - webViewTitle, - webViewInspector, - webViewWebSettings, - webViewViewSourceMode, - webViewTransparent, - webViewEditable, - webViewUri, - webViewCopyTargetList, - webViewPasteTargetList, - webViewWindowFeatures, -#if WEBKIT_CHECK_VERSION (1,1,18) - webViewIconUri, -#endif - -#if WEBKIT_CHECK_VERSION (1,1,20) - webViewImContext, -#endif - --- * Signals - loadStarted, - loadCommitted, - progressChanged, - loadFinished, - loadError, - titleChanged, - hoveringOverLink, - createWebView, - webViewReady, - closeWebView, - consoleMessage, - copyClipboard, - cutClipboard, - pasteClipboard, - populatePopup, - printRequested, - scriptAlert, - scriptConfirm, - scriptPrompt, - statusBarTextChanged, - selectAll, - selectionChanged, - setScrollAdjustments, - databaseQuotaExceeded, - documentLoadFinished, - downloadRequested, -#if WEBKIT_CHECK_VERSION (1,1,18) - iconLoaded, -#endif - redo, - undo, - mimeTypePolicyDecisionRequested, - moveCursor, - navigationPolicyDecisionRequested, - newWindowPolicyDecisionRequested, - resourceRequestStarting, -#if WEBKIT_CHECK_VERSION (1,1,23) - geolocationPolicyDecisionCancelled, - geolocationPolicyDecisionRequested, -#endif -) where - -import Control.Monad (liftM) - -import System.Glib.FFI -import System.Glib.UTFString -import System.Glib.GList -import System.Glib.Attributes -import System.Glib.Properties -import System.Glib.GError -import Graphics.UI.Gtk.Gdk.Events - -{#import Graphics.UI.Gtk.Abstract.Object#} (makeNewObject) -{#import Graphics.UI.Gtk.WebKit.Types#} -{#import Graphics.UI.Gtk.WebKit.Signals#} -{#import Graphics.UI.Gtk.WebKit.Internal#} -{#import System.Glib.GObject#} -{#import Graphics.UI.Gtk.General.Selection#} ( TargetList ) -{#import Graphics.UI.Gtk.MenuComboToolbar.Menu#} -{#import Graphics.UI.Gtk.General.Enums#} - -{#context lib="webkit" prefix ="webkit"#} - ------------------- --- Enums - -{#enum NavigationResponse {underscoreToCase}#} - -{#enum WebViewTargetInfo as TargetInfo {underscoreToCase}#} - -{#enum LoadStatus {underscoreToCase}#} - ------------------- --- Constructors - - --- | Create a new 'WebView' widget. --- --- It is a 'Widget' you can embed in a 'ScrolledWindow'. --- --- You can load any URI into the 'WebView' or any kind of data string. -webViewNew :: IO WebView -webViewNew = do - isGthreadInited <- liftM toBool {#call g_thread_get_initialized#} - if not isGthreadInited then {#call g_thread_init#} nullPtr - else return () - makeNewObject mkWebView $ liftM castPtr {#call web_view_new#} - - --- | Apply 'WebSettings' to a given 'WebView' --- --- !!NOTE!!, currently lack of useful APIs of 'WebSettings' in webkitgtk. --- If you want to set the encoding, font family or font size of the 'WebView', --- please use related functions. - -webViewSetWebSettings :: - (WebViewClass self, WebSettingsClass settings) => self - -> settings - -> IO () -webViewSetWebSettings webview websettings = - {#call web_view_set_settings#} (toWebView webview) (toWebSettings websettings) - --- | Return the 'WebSettings' currently used by 'WebView'. -webViewGetWebSettings :: - WebViewClass self => self - -> IO WebSettings -webViewGetWebSettings webview = - makeNewGObject mkWebSettings $ {#call web_view_get_settings#} (toWebView webview) - --- | Returns the instance of WebKitWebWindowFeatures held by the given WebKitWebView. -webViewGetWindowFeatures :: - WebViewClass self => self - -> IO WebWindowFeatures -webViewGetWindowFeatures webview = - makeNewGObject mkWebWindowFeatures $ {#call web_view_get_window_features#} (toWebView webview) - -#if WEBKIT_CHECK_VERSION (1,1,18) --- | Obtains the URI for the favicon for the given WebKitWebView, or 'Nothing' if there is none. --- --- * Since 1.1.18 -webViewGetIconUri :: WebViewClass self => self -> IO (Maybe String) -webViewGetIconUri webview = - {#call webkit_web_view_get_icon_uri #} (toWebView webview) - >>= maybePeek peekUTFString -#endif - - --- | Return the main 'WebFrame' of the given 'WebView'. -webViewGetMainFrame :: - WebViewClass self => self - -> IO WebFrame -webViewGetMainFrame webview = - makeNewGObject mkWebFrame $ {#call web_view_get_main_frame#} (toWebView webview) - --- | Return the focused 'WebFrame' of the given 'WebView'. -webViewGetFocusedFrame :: - WebViewClass self => self - -> IO WebFrame -webViewGetFocusedFrame webview = - makeNewGObject mkWebFrame $ {#call web_view_get_focused_frame#} (toWebView webview) - - --- |Requests loading of the specified URI string in a 'WebView' -webViewLoadUri :: - WebViewClass self => self - -> String -- ^ @uri@ - an URI string. - -> IO() -webViewLoadUri webview url = - withCString url $ \urlPtr -> {#call web_view_load_uri#} - (toWebView webview) - urlPtr - --- |Determine whether 'WebView' has a previous history item. -webViewCanGoBack :: - WebViewClass self => self - -> IO Bool -- ^ True if able to move back, False otherwise. -webViewCanGoBack webview = - liftM toBool $ {#call web_view_can_go_back#} (toWebView webview) - --- |Determine whether 'WebView' has a next history item. -webViewCanGoForward :: - WebViewClass self => self - -> IO Bool -- ^ True if able to move forward, False otherwise. -webViewCanGoForward webview = - liftM toBool $ {#call web_view_can_go_forward#} (toWebView webview) - --- |Loads the previous history item. -webViewGoBack :: - WebViewClass self => self - -> IO () -webViewGoBack webview = - {#call web_view_go_back#} (toWebView webview) - --- |Loads the next history item. -webViewGoForward :: - WebViewClass self => self - -> IO () -webViewGoForward webview = - {#call web_view_go_forward#} (toWebView webview) - --- |Set the 'WebView' to maintian a back or forward list of history items. -webViewSetMaintainsBackForwardList :: - WebViewClass self => self - -> Bool -- ^ @flag@ - to tell the view to maintain a back or forward list. - -> IO() -webViewSetMaintainsBackForwardList webview flag = - {#call web_view_set_maintains_back_forward_list#} - (toWebView webview) - (fromBool flag) - --- |Return the 'WebBackForwardList' -webViewGetBackForwardList :: - WebViewClass self => self - -> IO WebBackForwardList -webViewGetBackForwardList webview = - makeNewGObject mkWebBackForwardList $ - {#call web_view_get_back_forward_list#} - (toWebView webview) - --- |Go to the specified 'WebHistoryItem' - -webViewGoToBackForwardItem :: - (WebViewClass self, WebHistoryItemClass item) => self - -> item - -> IO Bool -- ^ True if loading of item is successful, False if not. -webViewGoToBackForwardItem webview item = - liftM toBool $ {#call web_view_go_to_back_forward_item#} (toWebView webview) (toWebHistoryItem item) - --- |Determines whether 'WebView' has a history item of @steps@. --- --- Negative values represent steps backward while positive values --- represent steps forward - -webViewCanGoBackOrForward :: - WebViewClass self => self - -> Int -- ^ @steps@ - the number of steps - -> IO Bool -- ^ True if able to move back or forward the given number of steps, - -- False otherwise -webViewCanGoBackOrForward webview steps = - liftM toBool $ - {#call web_view_can_go_back_or_forward#} - (toWebView webview) - (fromIntegral steps) - --- |Loads the history item that is the number of @steps@ away from the current item. --- --- Negative values represent steps backward while positive values represent steps forward. - -webViewGoBackOrForward :: - WebViewClass self => self - -> Int - -> IO () -webViewGoBackOrForward webview steps = - {#call web_view_go_back_or_forward#} - (toWebView webview) - (fromIntegral steps) - --- |Determines whether or not it is currently possible to redo the last editing command in the view -webViewCanRedo :: - WebViewClass self => self - -> IO Bool -webViewCanRedo webview = - liftM toBool $ - {#call web_view_can_redo#} (toWebView webview) --- |Determines whether or not it is currently possible to undo the last editing command in the view -webViewCanUndo :: - WebViewClass self => self - -> IO Bool -webViewCanUndo webview = - liftM toBool $ - {#call web_view_can_undo#} (toWebView webview) - --- |Redoes the last editing command in the view, if possible. -webViewRedo :: - WebViewClass self => self - -> IO() -webViewRedo webview = - {#call web_view_redo#} (toWebView webview) - --- |Undoes the last editing command in the view, if possible. -webViewUndo :: - WebViewClass self => self - -> IO() -webViewUndo webview = - {#call web_view_undo#} (toWebView webview) - --- | Returns whether or not a @mimetype@ can be displayed using this view. -webViewCanShowMimeType :: - WebViewClass self => self - -> String -- ^ @mimetype@ - a MIME type - -> IO Bool -- ^ True if the @mimetype@ can be displayed, otherwise False -webViewCanShowMimeType webview mime = - withCString mime $ \mimePtr -> - liftM toBool $ - {#call web_view_can_show_mime_type#} - (toWebView webview) - mimePtr - --- | Returns whether the user is allowed to edit the document. -webViewGetEditable :: - WebViewClass self => self - -> IO Bool -webViewGetEditable webview = - liftM toBool $ - {#call web_view_get_editable#} (toWebView webview) - --- | Sets whether allows the user to edit its HTML document. -webViewSetEditable :: - WebViewClass self => self - -> Bool - -> IO () -webViewSetEditable webview editable = - {#call web_view_set_editable#} (toWebView webview) (fromBool editable) - --- | Returns whether 'WebView' is in view source mode -webViewGetViewSourceMode :: - WebViewClass self => self - -> IO Bool -webViewGetViewSourceMode webview = - liftM toBool $ - {#call web_view_get_view_source_mode#} (toWebView webview) - --- | Set whether the view should be in view source mode. --- --- Setting this mode to TRUE before loading a URI will display --- the source of the web page in a nice and readable format. -webViewSetViewSourceMode :: - WebViewClass self => self - -> Bool - -> IO () -webViewSetViewSourceMode webview mode = - {#call web_view_set_view_source_mode#} (toWebView webview) (fromBool mode) - --- | Returns whether the 'WebView' has a transparent background -webViewGetTransparent :: - WebViewClass self => self - -> IO Bool -webViewGetTransparent webview = - liftM toBool $ - {#call web_view_get_transparent#} (toWebView webview) --- |Sets whether the WebKitWebView has a transparent background. --- --- Pass False to have the 'WebView' draw a solid background (the default), --- otherwise pass True. -webViewSetTransparent :: - WebViewClass self => self - -> Bool - -> IO () -webViewSetTransparent webview trans = - {#call web_view_set_transparent#} (toWebView webview) (fromBool trans) - --- |Obtains the 'WebInspector' associated with the 'WebView' -webViewGetInspector :: - WebViewClass self => self - -> IO WebInspector -webViewGetInspector webview = - makeNewGObject mkWebInspector $ {#call web_view_get_inspector#} (toWebView webview) - --- |Requests loading of the specified asynchronous client request. --- --- Creates a provisional data source that will transition to a committed data source once --- any data has been received. --- use 'webViewStopLoading' to stop the load. - -webViewLoadRequest :: - (WebViewClass self, NetworkRequestClass request) => self - -> request - -> IO() -webViewLoadRequest webview request = - {#call web_view_load_request#} (toWebView webview) (toNetworkRequest request) - - - - --- |Returns the zoom level of 'WebView' --- --- i.e. the factor by which elements in the page are scaled with respect to their original size. - -webViewGetZoomLevel :: - WebViewClass self => self - -> IO Float -- ^ the zoom level of 'WebView' -webViewGetZoomLevel webview = - liftM realToFrac $ - {#call web_view_get_zoom_level#} (toWebView webview) - --- |Sets the zoom level of 'WebView'. -webViewSetZoomLevel :: - WebViewClass self => self - -> Float -- ^ @zoom_level@ - the new zoom level - -> IO () -webViewSetZoomLevel webview zlevel = - {#call web_view_set_zoom_level#} (toWebView webview) (realToFrac zlevel) - --- |Loading the @content@ string as html. The URI passed in base_uri has to be an absolute URI. - -webViewLoadHtmlString :: - WebViewClass self => self - -> String -- ^ @content@ - the html string - -> String -- ^ @base_uri@ - the base URI - -> IO() -webViewLoadHtmlString webview htmlstr url = - withCString htmlstr $ \htmlPtr -> - withCString url $ \urlPtr -> - {#call web_view_load_html_string#} (toWebView webview) htmlPtr urlPtr - --- | Requests loading of the given @content@ with the specified @mime_type@, @encoding@ and @base_uri@. --- --- If @mime_type@ is @Nothing@, "text/html" is assumed. --- --- If @encoding@ is @Nothing@, "UTF-8" is assumed. --- -webViewLoadString :: - WebViewClass self => self - -> String -- ^ @content@ - the content string to be loaded. - -> (Maybe String) -- ^ @mime_type@ - the MIME type or @Nothing@. - -> (Maybe String) -- ^ @encoding@ - the encoding or @Nothing@. - -> String -- ^ @base_uri@ - the base URI for relative locations. - -> IO() -webViewLoadString webview content mimetype encoding baseuri = - withCString content $ \contentPtr -> - maybeWith withCString mimetype $ \mimetypePtr -> - maybeWith withCString encoding $ \encodingPtr -> - withCString baseuri $ \baseuriPtr -> - {#call web_view_load_string#} - (toWebView webview) - contentPtr - mimetypePtr - encodingPtr - baseuriPtr - --- |Returns the 'WebView' document title -webViewGetTitle :: - WebViewClass self => self - -> IO (Maybe String) -- ^ the title of 'WebView' or Nothing in case of failed. -webViewGetTitle webview = - {#call web_view_get_title#} (toWebView webview) >>= maybePeek peekUTFString - --- |Returns the current URI of the contents displayed by the 'WebView' -webViewGetUri :: - WebViewClass self => self - -> IO (Maybe String) -- ^ the URI of 'WebView' or Nothing in case of failed. -webViewGetUri webview = - {#call web_view_get_uri#} (toWebView webview) >>= maybePeek peekUTFString - - --- | Stops and pending loads on the given data source. -webViewStopLoading :: - WebViewClass self => self - -> IO () -webViewStopLoading webview = - {#call web_view_stop_loading#} (toWebView webview) - --- | Reloads the 'WebView' -webViewReload :: - WebViewClass self => self - -> IO () -webViewReload webview = - {#call web_view_reload#} (toWebView webview) - --- | Reloads the 'WebView' without using any cached data. -webViewReloadBypassCache :: - WebViewClass self => self - -> IO() -webViewReloadBypassCache webview = - {#call web_view_reload_bypass_cache#} (toWebView webview) - --- | Increases the zoom level of 'WebView'. -webViewZoomIn :: - WebViewClass self => self - -> IO() -webViewZoomIn webview = - {#call web_view_zoom_in#} (toWebView webview) - --- | Decreases the zoom level of 'WebView'. -webViewZoomOut :: - WebViewClass self => self - -> IO() -webViewZoomOut webview = - {#call web_view_zoom_out#} (toWebView webview) - --- | Looks for a specified string inside 'WebView' -webViewSearchText :: - WebViewClass self => self - -> String -- ^ @text@ - a string to look for - -> Bool -- ^ @case_sensitive@ - whether to respect the case of text - -> Bool -- ^ @forward@ - whether to find forward or not - -> Bool -- ^ @wrap@ - whether to continue looking at beginning - -- after reaching the end - -> IO Bool -- ^ True on success or False on failure -webViewSearchText webview text case_sensitive forward wrap = - withCString text $ \textPtr -> - liftM toBool $ - {#call web_view_search_text#} - (toWebView webview) - textPtr - (fromBool case_sensitive) - (fromBool forward) - (fromBool wrap) - --- |Attempts to highlight all occurances of string inside 'WebView' -webViewMarkTextMatches :: - WebViewClass self => self - -> String -- ^ @string@ - a string to look for - -> Bool -- ^ @case_sensitive@ - whether to respect the case of text - -> Int -- ^ @limit@ - the maximum number of strings to look for or 0 for all - -> IO Int -- ^ the number of strings highlighted -webViewMarkTextMatches webview text case_sensitive limit = - withCString text $ \textPtr -> - liftM fromIntegral $ - {#call web_view_mark_text_matches#} - (toWebView webview) - textPtr - (fromBool case_sensitive) - (fromIntegral limit) - --- | Move the cursor in view as described by step and count. -webViewMoveCursor :: - WebViewClass self => self - -> MovementStep - -> Int - -> IO () -webViewMoveCursor webview step count = - {#call web_view_move_cursor#} (toWebView webview) (fromIntegral $ fromEnum step) (fromIntegral count) - --- | Removes highlighting previously set by 'webViewMarkTextMarches' -webViewUnMarkTextMatches :: - WebViewClass self => self - -> IO () -webViewUnMarkTextMatches webview = - {#call web_view_unmark_text_matches#} (toWebView webview) - --- | Highlights text matches previously marked by 'webViewMarkTextMatches' -webViewSetHighlightTextMatches :: - WebViewClass self => self - -> Bool -- ^ @highlight@ - whether to highlight text matches - -> IO () -webViewSetHighlightTextMatches webview highlight = - {#call web_view_set_highlight_text_matches#} - (toWebView webview) - (fromBool highlight) - --- | Execute the script specified by @script@ -webViewExecuteScript :: - WebViewClass self => self - -> String -- ^ @script@ - script to be executed - -> IO() -webViewExecuteScript webview script = - withCString script $ \scriptPtr -> - {#call web_view_execute_script#} (toWebView webview) scriptPtr - --- | Determines whether can cuts the current selection --- inside 'WebView' to the clipboard -webViewCanCutClipboard :: - WebViewClass self => self - -> IO Bool -webViewCanCutClipboard webview = - liftM toBool $ {#call web_view_can_cut_clipboard#} (toWebView webview) - --- | Determines whether can copies the current selection --- inside 'WebView' to the clipboard -webViewCanCopyClipboard :: WebViewClass self => self -> IO Bool -webViewCanCopyClipboard webview = - liftM toBool $ {#call web_view_can_copy_clipboard#} (toWebView webview) - --- | Determines whether can pastes the current contents of the clipboard --- to the 'WebView' -webViewCanPasteClipboard :: WebViewClass self => self -> IO Bool -webViewCanPasteClipboard webview = - liftM toBool $ {#call web_view_can_paste_clipboard#} (toWebView webview) - --- | Cuts the current selection inside 'WebView' to the clipboard. -webViewCutClipboard :: WebViewClass self => self -> IO() -webViewCutClipboard webview = - {#call web_view_cut_clipboard#} (toWebView webview) - --- | Copies the current selection inside 'WebView' to the clipboard. -webViewCopyClipboard :: WebViewClass self => self -> IO() -webViewCopyClipboard webview = - {#call web_view_copy_clipboard#} (toWebView webview) - --- | Pastes the current contents of the clipboard to the 'WebView' -webViewPasteClipboard :: WebViewClass self => self -> IO() -webViewPasteClipboard webview = - {#call web_view_paste_clipboard#} (toWebView webview) - --- | Deletes the current selection inside the 'WebView' -webViewDeleteSelection :: WebViewClass self => self -> IO () -webViewDeleteSelection webview = - {#call web_view_delete_selection#} (toWebView webview) - --- | Determines whether text was selected -webViewHasSelection :: WebViewClass self => self -> IO Bool -webViewHasSelection webview = - liftM toBool $ {#call web_view_has_selection#} (toWebView webview) - --- | Attempts to select everything inside the 'WebView' -webViewSelectAll :: WebViewClass self => self -> IO () -webViewSelectAll webview = - {#call web_view_select_all#} (toWebView webview) - --- | Returns whether the zoom level affects only text or all elements. -webViewGetFullContentZoom :: - WebViewClass self => self - -> IO Bool -- ^ False if only text should be scaled(the default) - -- True if the full content of the view should be scaled. -webViewGetFullContentZoom webview = - liftM toBool $ {#call web_view_get_full_content_zoom#} (toWebView webview) - --- | Sets whether the zoom level affects only text or all elements. -webViewSetFullContentZoom :: - WebViewClass self => self - -> Bool -- ^ @full_content_zoom@ - False if only text should be scaled (the default) - -- True if the full content of the view should be scaled. - -> IO () -webViewSetFullContentZoom webview full = - {#call web_view_set_full_content_zoom#} (toWebView webview) (fromBool full) - --- | Returns the default encoding of the 'WebView' -webViewGetEncoding :: - WebViewClass self => self - -> IO (Maybe String) -- ^ the default encoding or @Nothing@ in case of failed -webViewGetEncoding webview = - {#call web_view_get_encoding#} (toWebView webview) >>= maybePeek peekUTFString - --- | Sets the current 'WebView' encoding, --- without modifying the default one, and reloads the page -webViewSetCustomEncoding :: - WebViewClass self => self - -> (Maybe String) -- ^ @encoding@ - the new encoding, - -- or @Nothing@ to restore the default encoding. - -> IO () -webViewSetCustomEncoding webview encoding = - maybeWith withCString encoding $ \encodingPtr -> - {#call web_view_set_custom_encoding#} (toWebView webview) encodingPtr - --- | Returns the current encoding of 'WebView',not the default encoding. -webViewGetCustomEncoding :: - WebViewClass self => self - -> IO (Maybe String) -- ^ the current encoding string - -- or @Nothing@ if there is none set. -webViewGetCustomEncoding webview = - {#call web_view_get_custom_encoding#} (toWebView webview) >>= maybePeek peekUTFString - --- | Determines the current status of the load. -webViewGetLoadStatus :: - WebViewClass self => self - -> IO LoadStatus -- ^ the current load status:'LoadStatus' -webViewGetLoadStatus webview = - liftM (toEnum . fromIntegral) $ {#call web_view_get_load_status#} (toWebView webview) - --- | Determines the current progress of the load -webViewGetProgress :: - WebViewClass self => self - -> IO Double -- ^ the load progress -webViewGetProgress webview = - liftM realToFrac $ {#call web_view_get_progress#} (toWebView webview) - --- | This function returns the list of targets this 'WebView' can provide for clipboard copying and as DND source. --- The targets in the list are added with values from the 'WebViewTargetInfo' enum, --- using 'targetListAdd' and 'targetListAddTextTargets'. -webViewGetCopyTargetList :: - WebViewClass self => self - -> IO (Maybe TargetList) -webViewGetCopyTargetList webview = do - tlPtr <- {#call web_view_get_copy_target_list#} (toWebView webview) - if tlPtr==nullPtr then return Nothing else liftM Just (mkTargetList tlPtr) - --- | This function returns the list of targets this 'WebView' can provide for clipboard pasteing and as DND source. --- The targets in the list are added with values from the 'WebViewTargetInfo' enum, --- using 'targetListAdd' and 'targetListAddTextTargets'. -webViewGetPasteTargetList :: - WebViewClass self => self - -> IO (Maybe TargetList) -webViewGetPasteTargetList webview = do - tlPtr <- {#call web_view_get_paste_target_list#} (toWebView webview) - if tlPtr==nullPtr then return Nothing else liftM Just (mkTargetList tlPtr) - --- * Attibutes - --- | Zoom level of the 'WebView' instance -webViewZoomLevel :: WebViewClass self => Attr self Float -webViewZoomLevel = newAttr - webViewGetZoomLevel - webViewSetZoomLevel - --- | Whether the full content is scaled when zooming --- --- Default value: False -webViewFullContentZoom :: WebViewClass self => Attr self Bool -webViewFullContentZoom = newAttr - webViewGetFullContentZoom - webViewSetFullContentZoom - --- | The default encoding of the 'WebView' instance --- --- Default value: @Nothing@ -webViewEncoding :: WebViewClass self => ReadAttr self (Maybe String) -webViewEncoding = readAttr webViewGetEncoding - --- | Determines the current status of the load. --- --- Default value: @LoadFinished@ -webViewLoadStatus :: WebViewClass self => ReadAttr self LoadStatus -webViewLoadStatus = readAttr webViewGetLoadStatus - --- |Determines the current progress of the load --- --- Default Value: 1 -webViewProgress :: WebViewClass self => ReadAttr self Double -webViewProgress = readAttr webViewGetProgress - - --- | The associated webSettings of the 'WebView' instance -webViewWebSettings :: WebViewClass self => Attr self WebSettings -webViewWebSettings = newAttr - webViewGetWebSettings - webViewSetWebSettings - - --- | Title of the 'WebView' instance -webViewTitle :: WebViewClass self => ReadAttr self (Maybe String) -webViewTitle = readAttr webViewGetTitle - --- | The associated webInspector instance of the 'WebView' -webViewInspector :: WebViewClass self => ReadAttr self WebInspector -webViewInspector = readAttr webViewGetInspector - - --- | The custom encoding of the 'WebView' instance --- --- Default value: @Nothing@ -webViewCustomEncoding :: WebViewClass self => Attr self (Maybe String) -webViewCustomEncoding = newAttr - webViewGetCustomEncoding - webViewSetCustomEncoding - --- | view source mode of the 'WebView' instance -webViewViewSourceMode :: WebViewClass self => Attr self Bool -webViewViewSourceMode = newAttr - webViewGetViewSourceMode - webViewSetViewSourceMode - --- | transparent background of the 'WebView' instance -webViewTransparent :: WebViewClass self => Attr self Bool -webViewTransparent = newAttr - webViewGetTransparent - webViewSetTransparent - --- | Whether content of the 'WebView' can be modified by the user --- --- Default value: @False@ -webViewEditable :: WebViewClass self => Attr self Bool -webViewEditable = newAttr - webViewGetEditable - webViewSetEditable - --- | Returns the current URI of the contents displayed by the @web_view@. --- --- Default value: Nothing -webViewUri :: WebViewClass self => ReadAttr self (Maybe String) -webViewUri = readAttr webViewGetUri - --- | The list of targets this web view supports for clipboard copying. -webViewCopyTargetList :: WebViewClass self => ReadAttr self (Maybe TargetList) -webViewCopyTargetList = readAttr webViewGetCopyTargetList - --- | The list of targets this web view supports for clipboard pasteing. -webViewPasteTargetList :: WebViewClass self => ReadAttr self (Maybe TargetList) -webViewPasteTargetList = readAttr webViewGetPasteTargetList - --- | An associated 'WebWindowFeatures' instance. -webViewWindowFeatures :: WebViewClass self => Attr self WebWindowFeatures -webViewWindowFeatures = - newAttrFromObjectProperty "window-features" - {#call pure webkit_web_window_features_get_type#} - -#if WEBKIT_CHECK_VERSION (1,1,18) --- | The URI for the favicon for the WebKitWebView. --- --- Default value: 'Nothing' --- --- * Since 1.1.18 -webViewIconUri :: WebViewClass self => ReadAttr self String -webViewIconUri = readAttrFromStringProperty "icon-uri" -#endif - -#if WEBKIT_CHECK_VERSION (1,1,20) --- | The 'IMMulticontext' for the WebKitWebView. --- --- This is the input method context used for all text entry widgets inside the WebKitWebView. It can be --- used to generate context menu items for controlling the active input method. --- --- * Since 1.1.20 -webViewImContext :: WebViewClass self => ReadAttr self IMContext -webViewImContext = - readAttrFromObjectProperty "im-context" - {#call pure gtk_im_context_get_type #} -#endif - --- * Signals - --- | When Document title changed, this signal is emitted. --- --- It can be used to set the Application 'Window' title. --- --- webframe - which 'WebFrame' changes the document title. --- --- title - current title string. -titleChanged :: WebViewClass self => Signal self ( WebFrame -> String -> IO() ) -titleChanged = - Signal (connect_OBJECT_STRING__NONE "title_changed") - - --- | When the cursor is over a link, this signal is emitted. --- --- title - the link's title or @Nothing@ in case of failure. --- --- uri - the URI the link points to or @Nothing@ in case of failure. -hoveringOverLink :: WebViewClass self => Signal self (Maybe String -> Maybe String -> IO()) -hoveringOverLink = - Signal (connect_MSTRING_MSTRING__NONE "hovering_over_link") - --- | When a 'WebFrame' begins to load, this signal is emitted -loadStarted :: WebViewClass self => Signal self (WebFrame -> IO()) -loadStarted = Signal (connect_OBJECT__NONE "load_started") - --- | When a 'WebFrame' loaded the first data, this signal is emitted -loadCommitted :: WebViewClass self => Signal self (WebFrame -> IO()) -loadCommitted = Signal (connect_OBJECT__NONE "load_committed") - - --- | When the global progress changed, this signal is emitted --- --- the global progress will be passed back to user function -progressChanged :: WebViewClass self => Signal self (Int-> IO()) -progressChanged = - Signal (connect_INT__NONE "load_progress_changed") - --- | When loading finished, this signal is emitted -loadFinished :: WebViewClass self => Signal self (WebFrame -> IO()) -loadFinished = - Signal (connect_OBJECT__NONE "load_finished") - --- | When An error occurred while loading. --- --- By default, if the signal is not handled, --- the WebView will display a stock error page. --- --- You need to handle the signal --- if you want to provide your own error page. --- --- The URI that triggered the error and the 'GError' will be passed back to user function. -loadError :: WebViewClass self => Signal self (WebFrame -> String -> GError -> IO Bool) -loadError = Signal (connect_OBJECT_STRING_BOXED__BOOL "load_error" peek) - -createWebView :: WebViewClass self => Signal self (WebFrame -> IO WebView) -createWebView = Signal (connect_OBJECT__OBJECTPTR "create_web_view") - --- | Emitted when closing a WebView is requested. --- --- This occurs when a call is made from JavaScript's window.close function. --- The default signal handler does not do anything. --- It is the owner's responsibility to hide or delete the 'WebView', if necessary. --- --- User function should return True to stop the handlers from being invoked for the event --- or False to propagate the event furter -closeWebView :: WebViewClass self => Signal self (IO Bool) -closeWebView = - Signal (connect_NONE__BOOL "close_web_view") - --- | A JavaScript console message was created. -consoleMessage :: WebViewClass self => Signal self (String -> String -> Int -> String -> IO Bool) -consoleMessage = Signal (connect_STRING_STRING_INT_STRING__BOOL "console_message") - --- | The 'copyClipboard' signal is a keybinding signal which gets emitted to copy the selection to the clipboard. --- --- The default bindings for this signal are Ctrl-c and Ctrl-Insert. -copyClipboard :: WebViewClass self => Signal self (IO ()) -copyClipboard = Signal (connect_NONE__NONE "copy_clipboard") - --- | The 'cutClipboard' signal is a keybinding signal which gets emitted to cut the selection to the clipboard. --- --- The default bindings for this signal are Ctrl-x and Shift-Delete. -cutClipboard :: WebViewClass self => Signal self (IO ()) -cutClipboard = Signal (connect_NONE__NONE "cut_clipboard") - --- | The 'pasteClipboard' signal is a keybinding signal which gets emitted to paste the contents of the clipboard into the Web view. --- --- The default bindings for this signal are Ctrl-v and Shift-Insert. -pasteClipboard :: WebViewClass self => Signal self (IO ()) -pasteClipboard = Signal (connect_NONE__NONE "paste_clipboard") - --- | When a context menu is about to be displayed this signal is emitted. -populatePopup :: WebViewClass self => Signal self (Menu -> IO ()) -populatePopup = Signal (connect_OBJECT__NONE "populate_popup") - --- | Emitted when printing is requested by the frame, usually because of a javascript call. --- When handling this signal you should call 'webFramePrintFull' or 'webFramePrint' to do the actual printing. --- --- The default handler will present a print dialog and carry a print operation. --- Notice that this means that if you intend to ignore a print --- request you must connect to this signal, and return True. -printRequested :: WebViewClass self => Signal self (WebFrame -> IO Bool) -printRequested = Signal (connect_OBJECT__BOOL "print_requested") - --- | A JavaScript alert dialog was created. -scriptAlert :: WebViewClass self => Signal self (WebFrame -> String -> IO Bool) -scriptAlert = Signal (connect_OBJECT_STRING__BOOL "scriptAlert") - --- | A JavaScript confirm dialog was created, providing Yes and No buttons. -scriptConfirm :: WebViewClass self => Signal self (WebFrame -> String -> IO Bool) -scriptConfirm = Signal (connect_OBJECT_STRING__BOOL "script_confirm") - --- | A JavaScript prompt dialog was created, providing an entry to input text. -scriptPrompt :: WebViewClass self => Signal self (WebFrame -> String -> String -> IO Bool) -scriptPrompt = Signal (connect_OBJECT_STRING_STRING__BOOL "script_prompt") - --- | When status-bar text changed, this signal will emitted. -statusBarTextChanged :: WebViewClass self => Signal self (String -> IO ()) -statusBarTextChanged = Signal (connect_STRING__NONE "status_bar_text_changed") - - - --- | The 'selectAll' signal is a keybinding signal which gets emitted to select the complete contents of the text view. --- --- The default bindings for this signal is Ctrl-a. -selectAll :: WebViewClass self => Signal self (IO ()) -selectAll = Signal (connect_NONE__NONE "select_all") - --- | When selection changed, this signal is emitted. -selectionChanged :: WebViewClass self => Signal self (IO ()) -selectionChanged = Signal (connect_NONE__NONE "selection_changed") - --- | When set scroll adjustments, this signal is emitted. -setScrollAdjustments :: WebViewClass self => Signal self (Adjustment -> Adjustment -> IO ()) -setScrollAdjustments = Signal (connect_OBJECT_OBJECT__NONE "set_scroll_adjustments") - --- | The 'databaseQuotaExceeded' signal will be emitted when a Web Database exceeds the quota of its security origin. --- This signal may be used to increase the size of the quota before the originating operation fails. -databaseQuotaExceeded :: WebViewClass self => Signal self (WebFrame -> WebDatabase -> IO ()) -databaseQuotaExceeded = Signal (connect_OBJECT_OBJECT__NONE "database_quota_exceeded") - --- | When document loading finished, this signal is emitted -documentLoadFinished :: WebViewClass self => Signal self (WebFrame -> IO ()) -documentLoadFinished = Signal (connect_OBJECT__NONE "document_load_finished") - - --- | Emitted after new 'WebView' instance had been created in 'onCreateWebView' user function --- when the new 'WebView' should be displayed to the user. --- --- All the information about how the window should look, --- including size,position,whether the location, status and scroll bars should be displayed, --- is ready set. -webViewReady:: WebViewClass self => Signal self (IO Bool) -webViewReady = - Signal (connect_NONE__BOOL "web_view_ready") - --- | Emitted after A new 'Download' is being requested. --- --- By default, if the signal is not handled, the download is cancelled. --- --- Notice that while handling this signal you must set the target URI using 'downloadSetDestinationUri' --- --- If you intend to handle downloads yourself, return False in user function. -downloadRequested :: WebViewClass self => Signal self (Download -> IO Bool) -downloadRequested = - Signal (connect_OBJECT__BOOL "download_requested") - -#if WEBKIT_CHECK_VERSION (1,1,18) --- | Emitted after Icon loaded -iconLoaded :: WebViewClass self => Signal self (String -> IO ()) -iconLoaded = - Signal (connect_STRING__NONE "icon_loaded") -#endif - --- | The "redo" signal is a keybinding signal which gets emitted to redo the last editing command. --- --- The default binding for this signal is Ctrl-Shift-z -redo :: WebViewClass self => Signal self (IO ()) -redo = - Signal (connect_NONE__NONE "redo") - --- | The "undo" signal is a keybinding signal which gets emitted to undo the last editing command. --- --- The default binding for this signal is Ctrl-z -undo :: WebViewClass self => Signal self (IO ()) -undo = - Signal (connect_NONE__NONE "undo") - --- | Decide whether or not to display the given MIME type. --- If this signal is not handled, the default behavior is to show the content of the --- requested URI if WebKit can show this MIME type and the content disposition is not a download; --- if WebKit is not able to show the MIME type nothing happens. --- --- Notice that if you return True, meaning that you handled the signal, --- you are expected to be aware of the "Content-Disposition" header. --- A value of "attachment" usually indicates a download regardless of the MIME type, --- see also soupMessageHeadersGetContentDisposition' --- And you must call 'webPolicyDecisionIgnore', 'webPolicyDecisionDownload', or 'webPolicyDecisionUse' --- on the 'webPolicyDecision' object. -mimeTypePolicyDecisionRequested :: WebViewClass self => Signal self (WebFrame -> NetworkRequest -> String -> WebPolicyDecision -> IO Bool) -mimeTypePolicyDecisionRequested = Signal (connect_OBJECT_OBJECT_STRING_OBJECT__BOOL "mime_type_policy_decision_requested") - --- | The 'moveCursor' will be emitted to apply the cursor movement described by its parameters to the view. -moveCursor :: WebViewClass self => Signal self (MovementStep -> Int -> IO Bool) -moveCursor = Signal (connect_ENUM_INT__BOOL "move_cursor") - --- | Emitted when frame requests a navigation to another page. --- If this signal is not handled, the default behavior is to allow the navigation. --- --- Notice that if you return True, meaning that you handled the signal, --- you are expected to be aware of the "Content-Disposition" header. --- A value of "attachment" usually indicates a download regardless of the MIME type, --- see also soupMessageHeadersGetContentDisposition' --- And you must call 'webPolicyDecisionIgnore', 'webPolicyDecisionDownload', or 'webPolicyDecisionUse' --- on the 'webPolicyDecision' object. -navigationPolicyDecisionRequested :: WebViewClass self => Signal self (WebFrame -> NetworkRequest -> WebNavigationAction -> WebPolicyDecision -> IO Bool) -navigationPolicyDecisionRequested = Signal (connect_OBJECT_OBJECT_OBJECT_OBJECT__BOOL "navigation_policy_decision_requested") - --- | Emitted when frame requests opening a new window. --- With this signal the browser can use the context of the request to decide about the new window. --- If the request is not handled the default behavior is to allow opening the new window to load the URI, --- which will cause a 'createWebView' signal emission where the browser handles the new window action --- but without information of the context that caused the navigation. --- The following 'navigationPolicyDecisionRequested' emissions will load the page --- after the creation of the new window just with the information of this new navigation context, --- without any information about the action that made this new window to be opened. --- --- Notice that if you return True, meaning that you handled the signal, --- you are expected to be aware of the "Content-Disposition" header. --- A value of "attachment" usually indicates a download regardless of the MIME type, --- see also soupMessageHeadersGetContentDisposition' --- And you must call 'webPolicyDecisionIgnore', 'webPolicyDecisionDownload', or 'webPolicyDecisionUse' --- on the 'webPolicyDecision' object. -newWindowPolicyDecisionRequested :: WebViewClass self => Signal self (WebFrame -> NetworkRequest -> WebNavigationAction -> WebPolicyDecision -> IO Bool) -newWindowPolicyDecisionRequested = Signal (connect_OBJECT_OBJECT_OBJECT_OBJECT__BOOL "new_window_policy_decision_requested") - --- | Emitted when a request is about to be sent. --- You can modify the request while handling this signal. --- You can set the URI in the 'NetworkRequest' object itself, --- and add/remove/replace headers using the SoupMessage object it carries, --- if it is present. See 'networkRequestGetMessage'. --- Setting the request URI to "about:blank" will effectively cause the request to load nothing, --- and can be used to disable the loading of specific resources. --- --- Notice that information about an eventual redirect is available in response's SoupMessage, --- not in the SoupMessage carried by the request. --- If response is NULL, then this is not a redirected request. --- --- The 'WebResource' object will be the same throughout all the lifetime of the resource, --- but the contents may change from inbetween signal emissions. -resourceRequestStarting :: WebViewClass self => Signal self (WebFrame -> WebResource -> Maybe NetworkRequest -> Maybe NetworkResponse -> IO ()) -resourceRequestStarting = Signal (connect_OBJECT_OBJECT_MOBJECT_MOBJECT__NONE "resource_request_starting") - -#if WEBKIT_CHECK_VERSION (1,1,23) --- | When a frame wants to cancel geolocation permission it had requested before. --- --- * Since 1.1.23 -geolocationPolicyDecisionCancelled :: WebViewClass self => Signal self (WebFrame -> IO ()) -geolocationPolicyDecisionCancelled = Signal (connect_OBJECT__NONE "geolocation_policy_decision_cancelled") - --- | When a frame wants to get its geolocation permission. The receiver must reply with a boolean wether --- it handled or not the request. If the request is not handled, default behaviour is to deny --- geolocation. --- --- * Since 1.1.23 -geolocationPolicyDecisionRequested :: WebViewClass self => Signal self (WebFrame -> GeolocationPolicyDecision -> IO ()) -geolocationPolicyDecisionRequested = Signal (connect_OBJECT_OBJECT__NONE "geolocation_policy_decision_requested") +{-# LANGUAGE CPP #-} +{-# LANGUAGE ViewPatterns #-} +-- -*-haskell-*- +----------------------------------------------------------------------------- +-- Module : Graphics.UI.Gtk.WebKit.WebView +-- Author : Cjacker Huang +-- Copyright : (c) 2009 Cjacker Huang +-- Copyright : (c) 2010 Andy Stewart +-- +-- This library is free software; you can redistribute it and/or +-- modify it under the terms of the GNU Lesser General Public +-- License as published by the Free Software Foundation; either +-- version 2.1 of the License, or (at your option) any later version. +-- +-- This library is distributed in the hope that it will be useful, +-- but WITHOUT ANY WARRANTY; without even the implied warranty of +-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +-- Lesser General Public License for more details. +-- +-- | +-- Maintainer : gtk2hs-users@lists.sourceforge.net +-- Stability : provisional +-- Portability : portable (depends on GHC) +-- +-- Note: +-- +-- Signal `window-object-cleared` can't be bound now, +-- because it needs JavaScriptCore that hasn't binding. +-- +-- Signal `create-plugin-widget` can't be bound now, +-- no idea how to bind `GHaskellTable` +-- +-- +-- * TODO: +-- +-- Binding for webkit_web_view_get_snapshot +----------------------------------------------------------------------------- + +module Graphics.UI.Gtk.WebKit.WebView ( +-- * Description +-- | Cf http://webkitgtk.org/reference/webkitgtk/stable/webkitgtk-webkitwebview.html. + +-- * Types + WebView, + WebViewClass, + +-- * Enums + NavigationResponse(..), + TargetInfo(..), + LoadStatus(..), + ViewMode(..), + +-- * Constructors + webViewNew, + +-- * Methods +-- ** Load +#if WEBKIT_CHECK_VERSION(1,1,1) + webViewLoadUri, +#endif + webViewLoadHtmlString, +#if WEBKIT_CHECK_VERSION(1,1,1) + webViewLoadRequest, +#endif + webViewLoadString, +#if WEBKIT_CHECK_VERSION(1,1,7) + webViewGetLoadStatus, +#endif +-- ** Reload + webViewStopLoading, + webViewReload, + webViewReloadBypassCache, +-- ** History + webViewCanGoBack, + webViewCanGoForward, + webViewGoBack, + webViewGoForward, + webViewGetBackForwardList, + webViewSetMaintainsBackForwardList, + webViewGoToBackForwardItem, + webViewCanGoBackOrForward, + webViewGoBackOrForward, +-- ** Zoom +#if WEBKIT_CHECK_VERSION(1,0,1) + webViewGetZoomLevel, + webViewSetZoomLevel, +#endif + webViewZoomIn, + webViewZoomOut, + webViewGetFullContentZoom, +#if WEBKIT_CHECK_VERSION(1,0,1) + webViewSetFullContentZoom, +#endif +-- ** Clipboard + webViewCanCutClipboard, + webViewCanCopyClipboard, + webViewCanPasteClipboard, + webViewCutClipboard, + webViewCopyClipboard, + webViewPasteClipboard, +-- ** Undo/Redo +#if WEBKIT_CHECK_VERSION (1,1,14) + webViewCanRedo, + webViewCanUndo, + webViewRedo, + webViewUndo, +#endif +-- ** Selection + webViewDeleteSelection, + webViewHasSelection, + webViewSelectAll, +-- ** Encoding + webViewGetEncoding, +#if WEBKIT_CHECK_VERSION(1,1,1) + webViewSetCustomEncoding, +#endif + webViewGetCustomEncoding, +-- ** View Mode +#if WEBKIT_CHECK_VERSION(1,3,4) + webViewGetViewMode, + webViewSetViewMode, +#endif + webViewGetViewSourceMode, +#if WEBKIT_CHECK_VERSION(1,1,14) + webViewSetViewSourceMode, +#endif +-- ** Transparent + webViewGetTransparent, + webViewSetTransparent, +-- ** Target List + webViewGetCopyTargetList, + webViewGetPasteTargetList, +-- ** Text Match + webViewMarkTextMatches, + webViewUnMarkTextMatches, + webViewSetHighlightTextMatches, +-- ** Icon +#if WEBKIT_CHECK_VERSION (1,1,18) + webViewGetIconUri, +#endif +#if WEBKIT_CHECK_VERSION (1,3,13) + webViewTryGetFaviconPixbuf, +#endif +-- ** Other + webViewExecuteScript, + + webViewCanShowMimeType, + webViewGetEditable, + webViewSetEditable, + webViewGetInspector, + + webViewGetProgress, + + webViewSearchText, + + webViewMoveCursor, + + webViewGetMainFrame, + webViewGetFocusedFrame, + + webViewSetWebSettings, + webViewGetWebSettings, + +#if WEBKIT_CHECK_VERSION(1,0,3) + webViewGetWindowFeatures, +#endif + +#if WEBKIT_CHECK_VERSION(1,1,4) + webViewGetTitle, + webViewGetUri, +#endif + +#if WEBKIT_CHECK_VERSION (1,3,1) + webViewGetDomDocument, +#endif + +#if WEBKIT_CHECK_VERSION (1,1,15) + -- webViewGetHitTestResult, +#endif + +#if WEBKIT_CHECK_VERSION(1,3,8) + -- webViewGetViewportAttributes, +#endif + +-- * Attributes +#if WEBKIT_CHECK_VERSION(1,0,1) + webViewZoomLevel, +#endif + webViewFullContentZoom, + webViewEncoding, + webViewCustomEncoding, + webViewLoadStatus, + webViewProgress, + webViewTitle, + webViewInspector, + webViewWebSettings, + webViewViewSourceMode, + webViewTransparent, + webViewEditable, + webViewUri, + webViewCopyTargetList, + webViewPasteTargetList, + webViewWindowFeatures, +#if WEBKIT_CHECK_VERSION (1,1,18) + webViewIconUri, +#endif + +#if WEBKIT_CHECK_VERSION (1,1,20) + webViewImContext, +#endif + +#if WEBKIT_CHECK_VERSION(1,3,4) + webViewViewMode, +#endif + +-- * Signals +-- ** Loading + loadStarted, + loadCommitted, + progressChanged, + loadFinished, + loadError, +#if WEBKIT_CHECK_VERSION (1,1,18) + iconLoaded, +#endif + documentLoadFinished, + resourceRequestStarting, + titleChanged, +-- ** Clipboard + copyClipboard, + cutClipboard, + pasteClipboard, +-- ** Script + consoleMessage, + scriptAlert, + scriptConfirm, + scriptPrompt, + statusBarTextChanged, + populatePopup, +-- ** Selection/edition + editingBegan, + editingEnded, + selectAll, + selectionChanged, +-- ** Decision request + mimeTypePolicyDecisionRequested, + navigationPolicyDecisionRequested, + newWindowPolicyDecisionRequested, +#if WEBKIT_CHECK_VERSION (1,1,23) + geolocationPolicyDecisionCancelled, + geolocationPolicyDecisionRequested, +#endif +-- ** Display + -- enteringFullscreen, + moveCursor, + setScrollAdjustments, +-- ** Other + hoveringOverLink, + createWebView, + webViewReady, +#if WEBKIT_CHECK_VERSION(1,1,11) + closeWebView, +#endif + printRequested, + databaseQuotaExceeded, + downloadRequested, + redo, + undo, +) where + +import Control.Monad (liftM, (<=<)) +import Data.ByteString (ByteString, useAsCString) + +import System.Glib.FFI +import System.Glib.UTFString +import System.Glib.GList +import System.Glib.Attributes as G +import System.Glib.Properties +import System.Glib.GError +import Graphics.UI.Gtk.Gdk.Events + +{#import Graphics.UI.Gtk.Abstract.Object#} (makeNewObject) +{#import Graphics.UI.Gtk.WebKit.Types#} +{#import Graphics.UI.Gtk.WebKit.Signals#} +{#import Graphics.UI.Gtk.WebKit.Internal#} +{#import System.Glib.GObject#} +{#import Graphics.UI.Gtk.General.Selection#} ( TargetList ) +{#import Graphics.UI.Gtk.MenuComboToolbar.Menu#} +{#import Graphics.UI.Gtk.General.Enums#} + +{#context lib="webkit" prefix="webkit"#} + +------------------ +-- Enums + +{#enum NavigationResponse {underscoreToCase} deriving(Eq, Show) #} +{#enum WebViewTargetInfo as TargetInfo {underscoreToCase} deriving(Eq, Show) #} +{#enum WebViewViewMode as ViewMode {underscoreToCase} deriving(Eq, Show) #} +{#enum LoadStatus {underscoreToCase} deriving(Eq, Show) #} + +------------------ +-- Constructors + + +-- | Create a new 'WebView' widget. +-- +-- It is a 'Widget' you can embed in a 'ScrolledWindow'. +-- +-- You can load any URI into the 'WebView' or any kind of data string. +webViewNew :: IO WebView +webViewNew = do + isGthreadInited <- liftM toBool {#call g_thread_get_initialized#} + if not isGthreadInited then {#call g_thread_init#} nullPtr + else return () + makeNewObject mkWebView $ liftM castPtr {#call web_view_new#} + + +-- | Apply 'WebSettings' to a given 'WebView' +-- +-- !!NOTE!!, currently lack of useful APIs of 'WebSettings' in webkitgtk. +-- If you want to set the encoding, font family or font size of the 'WebView', +-- please use related functions. +webViewSetWebSettings :: (WebViewClass self, WebSettingsClass settings) => self -> settings -> IO () +webViewSetWebSettings webview websettings = + {#call web_view_set_settings#} (toWebView webview) (toWebSettings websettings) + +-- | Return the 'WebSettings' currently used by 'WebView'. +webViewGetWebSettings :: WebViewClass self => self -> IO WebSettings +webViewGetWebSettings = makeNewGObject mkWebSettings . {#call web_view_get_settings#} . toWebView + +#if WEBKIT_CHECK_VERSION(1,0,3) +-- | Returns the instance of WebKitWebWindowFeatures held by the given WebKitWebView. +webViewGetWindowFeatures :: WebViewClass self => self -> IO WebWindowFeatures +webViewGetWindowFeatures = makeNewGObject mkWebWindowFeatures . {#call web_view_get_window_features#} . toWebView +#endif + +#if WEBKIT_CHECK_VERSION (1,1,18) +-- | Obtains the URI for the favicon for the given WebKitWebView, or 'Nothing' if there is none. +-- +-- * Since 1.1.18 +webViewGetIconUri :: (WebViewClass self, GlibString string) => self -> IO (Maybe string) +webViewGetIconUri webview = + {#call webkit_web_view_get_icon_uri #} (toWebView webview) + >>= maybePeek peekUTFString +#endif + +#if WEBKIT_CHECK_VERSION (1,3,13) +-- | Obtains a GdkPixbuf of the favicon for the given 'WebView'. +-- This will return @Nothing@ if there is no icon for the current 'WebView' or if the icon is in the database but not available at the moment of this call. +-- Use 'webViewGetIconUri' if you need to distinguish these cases. +-- +-- Usually you want to connect to WebKitWebView::icon-loaded and call this method in the callback. +-- +-- See also 'faviconDatabaseTryGetFaviconPixbuf'. Contrary to this function the icon database one returns the URL of the page containing the icon. +webViewTryGetFaviconPixbuf :: + WebView + -> Int -- ^ the desired width for the icon + -> Int -- ^ the desired height for the icon + -> IO (Maybe Pixbuf) -- ^ a new reference to a 'Pixbuf', or @Nothing@. +webViewTryGetFaviconPixbuf webView width length = do + faviconPtr <- {#call webkit_web_view_try_get_favicon_pixbuf#} webView (fromIntegral width) (fromIntegral length) + if faviconPtr == nullPtr then return Nothing else liftM Just . makeNewGObject mkPixbuf $ return faviconPtr +#endif + + +-- | Return the main 'WebFrame' of the given 'WebView'. +webViewGetMainFrame :: WebViewClass self => self -> IO WebFrame +webViewGetMainFrame = makeNewGObject mkWebFrame . {#call web_view_get_main_frame#} . toWebView + + +-- | Return the focused 'WebFrame' (if any) of the given 'WebView'. +webViewGetFocusedFrame :: WebViewClass self => self -> IO (Maybe WebFrame) +webViewGetFocusedFrame webView = do + framePtr <- {#call web_view_get_focused_frame#} $ toWebView webView + if framePtr == nullPtr then return Nothing else liftM Just . makeNewGObject mkWebFrame $ return framePtr + +#if WEBKIT_CHECK_VERSION(1,1,1) +-- | Requests loading of the specified URI string in a 'WebView' +webViewLoadUri :: (WebViewClass self, GlibString string) => self -> string -> IO () +webViewLoadUri webview url = withUTFString url $ {#call web_view_load_uri#} (toWebView webview) +#endif + +-- | Determine whether 'WebView' has a previous history item. +webViewCanGoBack :: + WebViewClass self => self + -> IO Bool -- ^ True if able to move back, False otherwise. +webViewCanGoBack webview = + liftM toBool $ {#call web_view_can_go_back#} (toWebView webview) + +-- | Determine whether 'WebView' has a next history item. +webViewCanGoForward :: + WebViewClass self => self + -> IO Bool -- ^ True if able to move forward, False otherwise. +webViewCanGoForward webview = + liftM toBool $ {#call web_view_can_go_forward#} (toWebView webview) + +-- | Loads the previous history item. +webViewGoBack :: WebViewClass self => self -> IO () +webViewGoBack = {#call web_view_go_back#} . toWebView + +-- | Loads the next history item. +webViewGoForward :: WebViewClass self => self -> IO () +webViewGoForward = {#call web_view_go_forward#} . toWebView + +-- | Set the 'WebView' to maintian a back or forward list of history items. +webViewSetMaintainsBackForwardList :: WebViewClass self => self + -> Bool -- ^ @flag@ - to tell the view to maintain a back or forward list. + -> IO() +webViewSetMaintainsBackForwardList webview flag = + {#call web_view_set_maintains_back_forward_list#} (toWebView webview) (fromBool flag) + +-- |Return the 'WebBackForwardList' +webViewGetBackForwardList :: + WebViewClass self => self + -> IO WebBackForwardList +webViewGetBackForwardList webview = + makeNewGObject mkWebBackForwardList $ + {#call web_view_get_back_forward_list#} + (toWebView webview) + +-- | Go to the specified 'WebHistoryItem' +webViewGoToBackForwardItem :: (WebViewClass self, WebHistoryItemClass item) => self + -> item + -> IO Bool -- ^ True if loading of item is successful, False if not. +webViewGoToBackForwardItem webview item = + liftM toBool $ {#call web_view_go_to_back_forward_item#} (toWebView webview) (toWebHistoryItem item) + +-- | Determines whether 'WebView' has a history item of @steps@. +-- +-- Negative values represent steps backward while positive values +-- represent steps forward +webViewCanGoBackOrForward :: WebViewClass self => self + -> Int -- ^ @steps@ - the number of steps + -> IO Bool -- ^ True if able to move back or forward the given number of steps, False otherwise +webViewCanGoBackOrForward webview steps = + liftM toBool $ + {#call web_view_can_go_back_or_forward#} + (toWebView webview) + (fromIntegral steps) + +-- | Loads the history item that is the number of @steps@ away from the current item. +-- Negative values represent steps backward while positive values represent steps forward. +webViewGoBackOrForward :: WebViewClass self => self -> Int -> IO () +webViewGoBackOrForward webview steps = {#call web_view_go_back_or_forward#} (toWebView webview) (fromIntegral steps) + +#if WEBKIT_CHECK_VERSION (1,1,14) +-- | Determines whether or not it is currently possible to redo the last editing command in the view +webViewCanRedo :: WebViewClass self => self -> IO Bool +webViewCanRedo = liftM toBool . {#call web_view_can_redo#} . toWebView + +-- | Determines whether or not it is currently possible to undo the last editing command in the view +webViewCanUndo :: WebViewClass self => self -> IO Bool +webViewCanUndo = liftM toBool . {#call web_view_can_undo#} . toWebView + +-- | Redoes the last editing command in the view, if possible. +webViewRedo :: WebViewClass self => self -> IO () +webViewRedo = {#call web_view_redo#} . toWebView + +-- | Undoes the last editing command in the view, if possible. +webViewUndo :: WebViewClass self => self -> IO () +webViewUndo = {#call web_view_undo#} . toWebView +#endif + +#if WEBKIT_CHECK_VERSION (1,0,3) +-- | Returns whether or not a @mimetype@ can be displayed using this view. +webViewCanShowMimeType :: (WebViewClass self, GlibString string) => self + -> string -- ^ @mimetype@ - a MIME type + -> IO Bool -- ^ True if the @mimetype@ can be displayed, otherwise False +webViewCanShowMimeType webview mime = withUTFString mime $ liftM toBool . {#call web_view_can_show_mime_type#} (toWebView webview) +#endif + +-- | Returns whether the user is allowed to edit the document. +webViewGetEditable :: WebViewClass self => self -> IO Bool +webViewGetEditable = liftM toBool . {#call web_view_get_editable#} . toWebView + +-- | Sets whether allows the user to edit its HTML document. +webViewSetEditable :: WebViewClass self => self -> Bool -> IO () +webViewSetEditable webview editable = {#call web_view_set_editable#} (toWebView webview) (fromBool editable) + +#if WEBKIT_CHECK_VERSION(1,3,4) +-- | Gets the value of the "view-mode" property of the 'WebView' +webViewGetViewMode :: WebViewClass self => self -> IO ViewMode +webViewGetViewMode = liftM (toEnum . fromIntegral) . {#call web_view_get_view_source_mode#} . toWebView + +webViewSetViewMode :: WebViewClass self => self -> ViewMode -> IO () +webViewSetViewMode (toWebView -> webView) viewMode = {#call web_view_set_view_source_mode#} webView (fromIntegral . fromEnum $ viewMode) +#endif + +-- | Returns whether 'WebView' is in view source mode +webViewGetViewSourceMode :: WebViewClass self => self -> IO Bool +webViewGetViewSourceMode = liftM toBool . {#call web_view_get_view_source_mode#} . toWebView + +#if WEBKIT_CHECK_VERSION(1,1,14) +-- | Set whether the view should be in view source mode. +-- Setting this mode to TRUE before loading a URI will display +-- the source of the web page in a nice and readable format. +webViewSetViewSourceMode :: WebViewClass self => self -> Bool -> IO () +webViewSetViewSourceMode webview mode = + {#call web_view_set_view_source_mode#} (toWebView webview) (fromBool mode) +#endif + +-- | Returns whether the 'WebView' has a transparent background +webViewGetTransparent :: WebViewClass self => self -> IO Bool +webViewGetTransparent = liftM toBool . {#call web_view_get_transparent#} . toWebView + +-- | Sets whether the WebKitWebView has a transparent background. +-- +-- Pass False to have the 'WebView' draw a solid background (the default), +-- otherwise pass True. +webViewSetTransparent :: WebViewClass self => self -> Bool -> IO () +webViewSetTransparent webview trans = + {#call web_view_set_transparent#} (toWebView webview) (fromBool trans) + +-- | Obtains the 'WebInspector' associated with the 'WebView' +webViewGetInspector :: WebViewClass self => self -> IO WebInspector +webViewGetInspector = makeNewGObject mkWebInspector . {#call web_view_get_inspector#} . toWebView + + +#if WEBKIT_CHECK_VERSION(1,1,1) +-- | Requests loading of the specified asynchronous client request. +-- Creates a provisional data source that will transition to a committed data source once any data has been received. +-- Use 'webViewStopLoading' to stop the load. +webViewLoadRequest :: (WebViewClass self, NetworkRequestClass request) => self -> request -> IO() +webViewLoadRequest webview request = {#call web_view_load_request#} (toWebView webview) (toNetworkRequest request) +#endif + + +#if WEBKIT_CHECK_VERSION(1,0,1) +-- | Returns the zoom level of 'WebView' +-- i.e. the factor by which elements in the page are scaled with respect to their original size. +webViewGetZoomLevel :: WebViewClass self => self -> IO Float +webViewGetZoomLevel = liftM realToFrac . {#call web_view_get_zoom_level#} . toWebView + +-- | Sets the zoom level of 'WebView'. +webViewSetZoomLevel :: WebViewClass self => self + -> Float -- ^ @zoom_level@ - the new zoom level + -> IO () +webViewSetZoomLevel webview zlevel = + {#call web_view_set_zoom_level#} (toWebView webview) (realToFrac zlevel) +#endif + + +-- | Loading the @content@ string as html. The URI passed in base_uri has to be an absolute URI. +-- Deprecated since webkit v1.1.1, use 'webViewLoadString' instead. +webViewLoadHtmlString :: (WebViewClass self, GlibString string) => self + -> string -- ^ @content@ - the html string + -> string -- ^ @base_uri@ - the base URI + -> IO() +webViewLoadHtmlString webview htmlstr url = withUTFString htmlstr $ \htmlPtr -> withUTFString url $ \urlPtr -> + {#call web_view_load_html_string#} (toWebView webview) htmlPtr urlPtr + +-- | Requests loading of the given @content@ with the specified @mime_type@ and @base_uri@. +-- If @mime_type@ is @Nothing@, "text/html" is assumed. +-- If want control over the encoding use `webViewLoadByteString` +webViewLoadString :: (WebViewClass self, GlibString string) => self + -> string -- ^ @content@ - the content string to be loaded. + -> (Maybe string) -- ^ @mime_type@ - the MIME type or @Nothing@. + -> string -- ^ @base_uri@ - the base URI for relative locations. + -> IO () +webViewLoadString webview content mimetype baseuri = + withUTFString content $ \contentPtr -> + maybeWith withUTFString mimetype $ \mimetypePtr -> + withUTFString baseuri $ \baseuriPtr -> + {#call web_view_load_string#} + (toWebView webview) + contentPtr + mimetypePtr + nullPtr + baseuriPtr + +-- | Requests loading of the given @content@ with the specified @mime_type@, @encoding@ and @base_uri@. +-- If @mime_type@ is @Nothing@, "text/html" is assumed. +-- If @encoding@ is @Nothing@, "UTF-8" is assumed. +webViewLoadByteString :: (WebViewClass self, GlibString string) => self + -> ByteString -- ^ @content@ - the content string to be loaded. + -> (Maybe string) -- ^ @mime_type@ - the MIME type or @Nothing@. + -> (Maybe string) -- ^ @encoding@ - the encoding or @Nothing@. + -> string -- ^ @base_uri@ - the base URI for relative locations. + -> IO () +webViewLoadByteString webview content mimetype encoding baseuri = + useAsCString content $ \contentPtr -> + maybeWith withUTFString mimetype $ \mimetypePtr -> + maybeWith withUTFString encoding $ \encodingPtr -> + withUTFString baseuri $ \baseuriPtr -> + {#call web_view_load_string#} + (toWebView webview) + contentPtr + mimetypePtr + encodingPtr + baseuriPtr + +#if WEBKIT_CHECK_VERSION(1,1,4) +-- | Returns the title of 'WebView' document, or Nothing in case of failure +webViewGetTitle :: (WebViewClass self, GlibString string) => self -> IO (Maybe string) +webViewGetTitle = maybePeek peekUTFString <=< {#call web_view_get_title#} . toWebView + +-- | Returns the current URI of the contents displayed by the 'WebView', or Nothing in case of failure +webViewGetUri :: (WebViewClass self, GlibString string) => self -> IO (Maybe string) +webViewGetUri = maybePeek peekUTFString <=< {#call web_view_get_uri#} . toWebView +#endif + + +-- | Stops and pending loads on the given data source. +webViewStopLoading :: WebViewClass self => self -> IO () +webViewStopLoading = {#call web_view_stop_loading#} . toWebView + +-- | Reloads the 'WebView' +webViewReload :: WebViewClass self => self -> IO () +webViewReload = {#call web_view_reload#} . toWebView + +-- | Reloads the 'WebView' without using any cached data. +webViewReloadBypassCache :: WebViewClass self => self -> IO () +webViewReloadBypassCache = {#call web_view_reload_bypass_cache#} . toWebView + +-- | Increases the zoom level of 'WebView'. +webViewZoomIn :: WebViewClass self => self -> IO() +webViewZoomIn = {#call web_view_zoom_in#} . toWebView + +-- | Decreases the zoom level of 'WebView'. +webViewZoomOut :: WebViewClass self => self -> IO () +webViewZoomOut = {#call web_view_zoom_out#} . toWebView + +-- | Looks for a specified string inside 'WebView' +webViewSearchText :: (WebViewClass self, GlibString string) => self + -> string -- ^ @text@ - a string to look for + -> Bool -- ^ @case_sensitive@ - whether to respect the case of text + -> Bool -- ^ @forward@ - whether to find forward or not + -> Bool -- ^ @wrap@ - whether to continue looking at beginning after reaching the end + -> IO Bool -- ^ True on success or False on failure +webViewSearchText webview text case_sensitive forward wrap = + withUTFString text $ \textPtr -> + liftM toBool $ + {#call web_view_search_text#} + (toWebView webview) + textPtr + (fromBool case_sensitive) + (fromBool forward) + (fromBool wrap) + +-- | Attempts to highlight all occurances of string inside 'WebView' +webViewMarkTextMatches :: (WebViewClass self, GlibString string) => self + -> string -- ^ @string@ - a string to look for + -> Bool -- ^ @case_sensitive@ - whether to respect the case of text + -> Int -- ^ @limit@ - the maximum number of strings to look for or 0 for all + -> IO Int -- ^ the number of strings highlighted +webViewMarkTextMatches webview text case_sensitive limit = withUTFString text $ \textPtr -> liftM fromIntegral $ + {#call web_view_mark_text_matches#} (toWebView webview) textPtr (fromBool case_sensitive) (fromIntegral limit) + +-- | Move the cursor in view as described by step and count. +webViewMoveCursor :: WebViewClass self => self -> MovementStep -> Int -> IO () +webViewMoveCursor webview step count = + {#call web_view_move_cursor#} (toWebView webview) (fromIntegral $ fromEnum step) (fromIntegral count) + +-- | Removes highlighting previously set by 'webViewMarkTextMarches' +webViewUnMarkTextMatches :: WebViewClass self => self -> IO () +webViewUnMarkTextMatches = {#call web_view_unmark_text_matches#} . toWebView + +-- | Highlights text matches previously marked by 'webViewMarkTextMatches' +webViewSetHighlightTextMatches :: WebViewClass self => self + -> Bool -- ^ @highlight@ - whether to highlight text matches + -> IO () +webViewSetHighlightTextMatches webview highlight = + {#call web_view_set_highlight_text_matches#} (toWebView webview) (fromBool highlight) + +-- | Execute the script specified by @script@ +webViewExecuteScript :: (WebViewClass self, GlibString string) => self + -> string -- ^ @script@ - script to be executed + -> IO() +webViewExecuteScript webview script = withUTFString script $ {#call web_view_execute_script#} (toWebView webview) + +-- | Determines whether can cuts the current selection inside 'WebView' to the clipboard +webViewCanCutClipboard :: WebViewClass self => self -> IO Bool +webViewCanCutClipboard = liftM toBool . {#call web_view_can_cut_clipboard#} . toWebView + +-- | Determines whether can copies the current selection +-- inside 'WebView' to the clipboard +webViewCanCopyClipboard :: WebViewClass self => self -> IO Bool +webViewCanCopyClipboard webview = + liftM toBool $ {#call web_view_can_copy_clipboard#} (toWebView webview) + +-- | Determines whether can pastes the current contents of the clipboard +-- to the 'WebView' +webViewCanPasteClipboard :: WebViewClass self => self -> IO Bool +webViewCanPasteClipboard webview = + liftM toBool $ {#call web_view_can_paste_clipboard#} (toWebView webview) + +-- | Cuts the current selection inside 'WebView' to the clipboard. +webViewCutClipboard :: WebViewClass self => self -> IO() +webViewCutClipboard webview = + {#call web_view_cut_clipboard#} (toWebView webview) + +-- | Copies the current selection inside 'WebView' to the clipboard. +webViewCopyClipboard :: WebViewClass self => self -> IO() +webViewCopyClipboard webview = + {#call web_view_copy_clipboard#} (toWebView webview) + +-- | Pastes the current contents of the clipboard to the 'WebView' +webViewPasteClipboard :: WebViewClass self => self -> IO () +webViewPasteClipboard = {#call web_view_paste_clipboard#} . toWebView + +-- | Deletes the current selection inside the 'WebView' +webViewDeleteSelection :: WebViewClass self => self -> IO () +webViewDeleteSelection = {#call web_view_delete_selection#} . toWebView + +-- | Determines whether text was selected +webViewHasSelection :: WebViewClass self => self -> IO Bool +webViewHasSelection = liftM toBool . {#call web_view_has_selection#} . toWebView + +-- | Attempts to select everything inside the 'WebView' +webViewSelectAll :: WebViewClass self => self -> IO () +webViewSelectAll = {#call web_view_select_all#} . toWebView + +-- | Returns whether the zoom level affects only text or all elements. +webViewGetFullContentZoom :: WebViewClass self => self + -> IO Bool -- ^ False if only text should be scaled(the default) + -- True if the full content of the view should be scaled. +webViewGetFullContentZoom = liftM toBool . {#call web_view_get_full_content_zoom#} . toWebView + +#if WEBKIT_CHECK_VERSION(1,0,1) +-- | Sets whether the zoom level affects only text or all elements. +webViewSetFullContentZoom :: WebViewClass self => self + -> Bool -- ^ @full_content_zoom@ - False if only text should be scaled (the default) + -- True if the full content of the view should be scaled. + -> IO () +webViewSetFullContentZoom webview full = + {#call web_view_set_full_content_zoom#} (toWebView webview) (fromBool full) +#endif + +-- | Returns the default encoding of the 'WebView' +webViewGetEncoding :: (WebViewClass self, GlibString string) => self + -> IO (Maybe string) -- ^ the default encoding or @Nothing@ in case of failed +webViewGetEncoding webview = {#call web_view_get_encoding#} (toWebView webview) >>= maybePeek peekUTFString + +#if WEBKIT_CHECK_VERSION(1,1,1) +-- | Sets the current 'WebView' encoding, +-- without modifying the default one, and reloads the page +webViewSetCustomEncoding :: (WebViewClass self, GlibString string) => self + -> (Maybe string) -- ^ @encoding@ - the new encoding, or @Nothing@ to restore the default encoding. + -> IO () +webViewSetCustomEncoding webview encoding = + maybeWith withUTFString encoding $ \encodingPtr -> + {#call web_view_set_custom_encoding#} (toWebView webview) encodingPtr +#endif + +-- | Returns the current encoding of 'WebView',not the default encoding. +webViewGetCustomEncoding :: (WebViewClass self, GlibString string) => self + -> IO (Maybe string) -- ^ the current encoding string or @Nothing@ if there is none set. +webViewGetCustomEncoding = maybePeek peekUTFString <=< {#call web_view_get_custom_encoding#} . toWebView + +#if WEBKIT_CHECK_VERSION(1,1,7) +-- | Determines the current status of the load. +webViewGetLoadStatus :: WebViewClass self => self -> IO LoadStatus +webViewGetLoadStatus = liftM (toEnum . fromIntegral) . {#call web_view_get_load_status#} . toWebView +#endif + +-- | Determines the current progress of the load +webViewGetProgress :: WebViewClass self => self + -> IO Double -- ^ the load progress +webViewGetProgress = liftM realToFrac . {#call web_view_get_progress#} . toWebView + +-- | This function returns the list of targets this 'WebView' can provide for clipboard copying and as DND source. +-- The targets in the list are added with values from the 'WebViewTargetInfo' enum, +-- using 'targetListAdd' and 'targetListAddTextTargets'. +webViewGetCopyTargetList :: WebViewClass self => self -> IO (Maybe TargetList) +webViewGetCopyTargetList webview = do + tlPtr <- {#call web_view_get_copy_target_list#} (toWebView webview) + if tlPtr == nullPtr then return Nothing else liftM Just (mkTargetList tlPtr) + +-- | This function returns the list of targets this 'WebView' can provide for clipboard pasteing and as DND source. +-- The targets in the list are added with values from the 'WebViewTargetInfo' enum, +-- using 'targetListAdd' and 'targetListAddTextTargets'. +webViewGetPasteTargetList :: WebViewClass self => self -> IO (Maybe TargetList) +webViewGetPasteTargetList = maybePeek mkTargetList <=< {#call web_view_get_paste_target_list#} . toWebView + +-- * Attibutes + +#if WEBKIT_CHECK_VERSION(1,0,1) +-- | Zoom level of the 'WebView' instance +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 => G.Attr self Bool +webViewFullContentZoom = newAttrFromBoolProperty "full-content-zoom" + +-- | The default encoding of the 'WebView' instance +-- +-- Default value: @Nothing@ +webViewEncoding :: (WebViewClass self, GlibString string) => ReadAttr self (Maybe string) +webViewEncoding = readAttrFromMaybeStringProperty "encoding" + +-- | Determines the current status of the load. +-- +-- Default value: @LoadFinished@ +webViewLoadStatus :: WebViewClass self => ReadAttr self LoadStatus +webViewLoadStatus = readAttrFromEnumProperty "load-status" {#call pure unsafe webkit_load_status_get_type#} + +-- |Determines the current progress of the load +-- +-- Default Value: 1 +webViewProgress :: WebViewClass self => ReadAttr self Double +webViewProgress = readAttrFromDoubleProperty "progress" + + +-- | The associated webSettings of the 'WebView' instance +webViewWebSettings :: WebViewClass self => G.Attr self WebSettings +webViewWebSettings = newAttr + webViewGetWebSettings + webViewSetWebSettings + + +-- | Title of the 'WebView' instance +webViewTitle :: (WebViewClass self, GlibString string) => ReadAttr self (Maybe string) +webViewTitle = readAttrFromMaybeStringProperty "title" + +-- | The associated webInspector instance of the 'WebView' +webViewInspector :: WebViewClass self => ReadAttr self WebInspector +webViewInspector = readAttr webViewGetInspector + + +-- | The custom encoding of the 'WebView' instance +-- +-- Default value: @Nothing@ +webViewCustomEncoding :: (WebViewClass self, GlibString string) => G.Attr self (Maybe string) +webViewCustomEncoding = newAttrFromMaybeStringProperty "custom-encoding" + +-- | view source mode of the 'WebView' instance +webViewViewSourceMode :: WebViewClass self => G.Attr self Bool +webViewViewSourceMode = newAttr + webViewGetViewSourceMode + webViewSetViewSourceMode + +-- | transparent background of the 'WebView' instance +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 => G.Attr self Bool +webViewEditable = newAttrFromBoolProperty "editable" + +-- | Returns the current URI of the contents displayed by the @web_view@. +-- +-- Default value: Nothing +webViewUri :: (WebViewClass self, GlibString string) => ReadAttr self (Maybe string) +webViewUri = readAttrFromMaybeStringProperty "uri" + +-- | The list of targets this web view supports for clipboard copying. +webViewCopyTargetList :: WebViewClass self => ReadAttr self (Maybe TargetList) +webViewCopyTargetList = readAttr webViewGetCopyTargetList + +-- | The list of targets this web view supports for clipboard pasteing. +webViewPasteTargetList :: WebViewClass self => ReadAttr self (Maybe TargetList) +webViewPasteTargetList = readAttr webViewGetPasteTargetList + +-- | An associated 'WebWindowFeatures' instance. +webViewWindowFeatures :: WebViewClass self => G.Attr self WebWindowFeatures +webViewWindowFeatures = + newAttrFromObjectProperty "window-features" + {#call pure webkit_web_window_features_get_type#} + +#if WEBKIT_CHECK_VERSION (1,1,18) +-- | The URI for the favicon for the WebKitWebView. +-- +-- Default value: 'Nothing' +-- +-- * Since 1.1.18 +webViewIconUri :: (WebViewClass self, GlibString string) => ReadAttr self (Maybe string) +webViewIconUri = readAttrFromMaybeStringProperty "icon-uri" +#endif + +#if WEBKIT_CHECK_VERSION (1,1,20) +-- | The 'IMMulticontext' for the WebKitWebView. +-- +-- This is the input method context used for all text entry widgets inside the WebKitWebView. It can be +-- used to generate context menu items for controlling the active input method. +-- +-- * Since 1.1.20 +webViewImContext :: WebViewClass self => ReadAttr self IMContext +webViewImContext = + readAttrFromObjectProperty "im-context" + {#call pure gtk_im_context_get_type #} +#endif + +#if WEBKIT_CHECK_VERSION(1,3,4) +-- | The "view-mode" property of the 'WebView' +webViewViewMode :: (WebViewClass self) => G.Attr self ViewMode +webViewViewMode = newAttr + webViewGetViewMode + webViewSetViewMode +#endif + +#if WEBKIT_CHECK_VERSION (1,3,1) +webViewGetDomDocument :: WebView -> IO (Maybe Document) +webViewGetDomDocument webView = do + docPtr <- {#call webkit_web_view_get_dom_document#} webView + if docPtr == nullPtr then return Nothing else liftM Just . makeNewGObject mkDocument $ return docPtr +#endif + + +-- #if WEBKIT_CHECK_VERSION (1,1,15) +-- -- | Does a "hit test" in the coordinates specified by @event@ to figure out context information about that position in the @web_view@. +-- webViewGetHitTestResult :: +-- WebView -- ^ @web_view +-- -> EventButton -- ^ @event@ +-- -> IO HitTestResult +-- webViewGetHitTestResult webView eventButton = makeNewGObject mkHitTestResult $ {#call webkit_web_view_get_hit_test_result#} webView eventButton +-- #endif + + +-- #if WEBKIT_CHECK_VERSION(1,3,8) +-- -- | Obtains the 'ViewportAttributes' associated with the 'WebView'. +-- -- Do note however that the viewport attributes object only contains valid information when the current page has a viewport meta tag. +-- -- You can check whether the data should be used by checking the "valid" property. +-- webViewGetViewportAttributes :: WebView -> IO ViewportAttributes +-- webViewGetViewportAttributes = makeNewGObject mkViewportAttributes . {#call webkit_web_view_get_viewport_attributes#} +-- #endif + + + +-- * Signals + +-- | When Document title changed, this signal is emitted. +-- +-- It can be used to set the Application 'Window' title. +-- +-- webframe - which 'WebFrame' changes the document title. +-- +-- title - current title string. +titleChanged :: (WebViewClass self, GlibString string) => Signal self ( WebFrame -> string -> IO() ) +titleChanged = Signal (connect_OBJECT_GLIBSTRING__NONE "title_changed") + + +-- | When the cursor is over a link, this signal is emitted. +-- +-- title - the link's title or @Nothing@ in case of failure. +-- +-- uri - the URI the link points to or @Nothing@ in case of failure. +hoveringOverLink :: (WebViewClass self, GlibString string) => Signal self (Maybe string -> Maybe string -> IO()) +hoveringOverLink = Signal (connect_MGLIBSTRING_MGLIBSTRING__NONE "hovering_over_link") + +-- | When a 'WebFrame' begins to load, this signal is emitted +loadStarted :: WebViewClass self => Signal self (WebFrame -> IO()) +loadStarted = Signal (connect_OBJECT__NONE "load_started") + +-- | When a 'WebFrame' loaded the first data, this signal is emitted +loadCommitted :: WebViewClass self => Signal self (WebFrame -> IO()) +loadCommitted = Signal (connect_OBJECT__NONE "load_committed") + + +-- | When the global progress changed, this signal is emitted +-- +-- the global progress will be passed back to user function +progressChanged :: WebViewClass self => Signal self (Int-> IO()) +progressChanged = Signal (connect_INT__NONE "load_progress_changed") + +-- | When loading finished, this signal is emitted +loadFinished :: WebViewClass self => Signal self (WebFrame -> IO()) +loadFinished = Signal (connect_OBJECT__NONE "load_finished") + +-- | When An error occurred while loading. +-- +-- By default, if the signal is not handled, +-- the WebView will display a stock error page. +-- +-- You need to handle the signal +-- if you want to provide your own error page. +-- +-- The URI that triggered the error and the 'GError' will be passed back to user function. +loadError :: (WebViewClass self, GlibString string) => Signal self (WebFrame -> string -> GError -> IO Bool) +loadError = Signal (connect_OBJECT_GLIBSTRING_BOXED__BOOL "load_error" peek) + +createWebView :: WebViewClass self => Signal self (WebFrame -> IO WebView) +createWebView = Signal (connect_OBJECT__OBJECTPTR "create_web_view") + +#if WEBKIT_CHECK_VERSION(1,1,11) +-- | Emitted when closing a WebView is requested. +-- +-- This occurs when a call is made from JavaScript's window.close function. +-- The default signal handler does not do anything. +-- It is the owner's responsibility to hide or delete the 'WebView', if necessary. +-- +-- User function should return True to stop the handlers from being invoked for the event +-- or False to propagate the event furter +closeWebView :: WebViewClass self => Signal self (IO Bool) +closeWebView = Signal (connect_NONE__BOOL "close_web_view") +#endif + +-- | A JavaScript console message was created. +consoleMessage :: (WebViewClass self, GlibString string) => Signal self (string -> string -> Int -> string -> IO Bool) +consoleMessage = Signal (connect_GLIBSTRING_GLIBSTRING_INT_GLIBSTRING__BOOL "console_message") + +-- | The 'copyClipboard' signal is a keybinding signal which gets emitted to copy the selection to the clipboard. +-- +-- The default bindings for this signal are Ctrl-c and Ctrl-Insert. +copyClipboard :: WebViewClass self => Signal self (IO ()) +copyClipboard = Signal (connect_NONE__NONE "copy_clipboard") + +-- | The 'cutClipboard' signal is a keybinding signal which gets emitted to cut the selection to the clipboard. +-- +-- The default bindings for this signal are Ctrl-x and Shift-Delete. +cutClipboard :: WebViewClass self => Signal self (IO ()) +cutClipboard = Signal (connect_NONE__NONE "cut_clipboard") + +-- | The 'pasteClipboard' signal is a keybinding signal which gets emitted to paste the contents of the clipboard into the Web view. +-- +-- The default bindings for this signal are Ctrl-v and Shift-Insert. +pasteClipboard :: WebViewClass self => Signal self (IO ()) +pasteClipboard = Signal (connect_NONE__NONE "paste_clipboard") + +-- | When a context menu is about to be displayed this signal is emitted. +populatePopup :: WebViewClass self => Signal self (Menu -> IO ()) +populatePopup = Signal (connect_OBJECT__NONE "populate_popup") + +-- | Emitted when printing is requested by the frame, usually because of a javascript call. +-- When handling this signal you should call 'webFramePrintFull' or 'webFramePrint' to do the actual printing. +-- +-- The default handler will present a print dialog and carry a print operation. +-- Notice that this means that if you intend to ignore a print +-- request you must connect to this signal, and return True. +printRequested :: WebViewClass self => Signal self (WebFrame -> IO Bool) +printRequested = Signal (connect_OBJECT__BOOL "print_requested") + +-- | A JavaScript alert dialog was created. +scriptAlert :: (WebViewClass self, GlibString string) => Signal self (WebFrame -> string -> IO Bool) +scriptAlert = Signal (connect_OBJECT_GLIBSTRING__BOOL "script_alert") + +-- | A JavaScript confirm dialog was created, providing Yes and No buttons. +scriptConfirm :: (WebViewClass self, GlibString string) => Signal self (WebFrame -> string -> IO Bool) +scriptConfirm = Signal (connect_OBJECT_GLIBSTRING__BOOL "script_confirm") + +-- | A JavaScript prompt dialog was created, providing an entry to input text. +scriptPrompt :: (WebViewClass self, GlibString string) => Signal self (WebFrame -> string -> string -> IO Bool) +scriptPrompt = Signal (connect_OBJECT_GLIBSTRING_GLIBSTRING__BOOL "script_prompt") + +-- | When status-bar text changed, this signal will emitted. +statusBarTextChanged :: (WebViewClass self, GlibString string) => Signal self (string -> IO ()) +statusBarTextChanged = Signal (connect_GLIBSTRING__NONE "status_bar_text_changed") + + +editingBegan :: WebViewClass self => Signal self (IO ()) +editingBegan = Signal (connect_NONE__NONE "editing_began") + + +editingEnded :: WebViewClass self => Signal self (IO ()) +editingEnded = Signal (connect_NONE__NONE "editing_ended") + + +-- | The 'selectAll' signal is a keybinding signal which gets emitted to select the complete contents of the text view. +-- +-- The default bindings for this signal is Ctrl-a. +selectAll :: WebViewClass self => Signal self (IO ()) +selectAll = Signal (connect_NONE__NONE "select_all") + +-- | When selection changed, this signal is emitted. +selectionChanged :: WebViewClass self => Signal self (IO ()) +selectionChanged = Signal (connect_NONE__NONE "selection_changed") + +-- | When set scroll adjustments, this signal is emitted. +setScrollAdjustments :: WebViewClass self => Signal self (Adjustment -> Adjustment -> IO ()) +setScrollAdjustments = Signal (connect_OBJECT_OBJECT__NONE "set_scroll_adjustments") + +-- | The 'databaseQuotaExceeded' signal will be emitted when a Web Database exceeds the quota of its security origin. +-- This signal may be used to increase the size of the quota before the originating operation fails. +databaseQuotaExceeded :: WebViewClass self => Signal self (WebFrame -> WebDatabase -> IO ()) +databaseQuotaExceeded = Signal (connect_OBJECT_OBJECT__NONE "database_quota_exceeded") + +-- | When document loading finished, this signal is emitted +documentLoadFinished :: WebViewClass self => Signal self (WebFrame -> IO ()) +documentLoadFinished = Signal (connect_OBJECT__NONE "document_load_finished") + + +-- | Emitted after new 'WebView' instance had been created in 'onCreateWebView' user function +-- when the new 'WebView' should be displayed to the user. +-- +-- All the information about how the window should look, +-- including size,position,whether the location, status and scroll bars should be displayed, +-- is ready set. +webViewReady:: WebViewClass self => Signal self (IO Bool) +webViewReady = + Signal (connect_NONE__BOOL "web_view_ready") + +-- | Emitted after A new 'Download' is being requested. +-- +-- By default, if the signal is not handled, the download is cancelled. +-- +-- Notice that while handling this signal you must set the target URI using 'downloadSetDestinationUri' +-- +-- If you intend to handle downloads yourself, return False in user function. +downloadRequested :: WebViewClass self => Signal self (Download -> IO Bool) +downloadRequested = + Signal (connect_OBJECT__BOOL "download_requested") + +#if WEBKIT_CHECK_VERSION (1,1,18) +-- | Emitted after Icon loaded +iconLoaded :: (WebViewClass self, GlibString string) => Signal self (string -> IO ()) +iconLoaded = + Signal (connect_GLIBSTRING__NONE "icon_loaded") +#endif + +-- | The "redo" signal is a keybinding signal which gets emitted to redo the last editing command. +-- +-- The default binding for this signal is Ctrl-Shift-z +redo :: WebViewClass self => Signal self (IO ()) +redo = Signal (connect_NONE__NONE "redo") + +-- | The "undo" signal is a keybinding signal which gets emitted to undo the last editing command. +-- +-- The default binding for this signal is Ctrl-z +undo :: WebViewClass self => Signal self (IO ()) +undo = Signal (connect_NONE__NONE "undo") + +-- | Decide whether or not to display the given MIME type. +-- If this signal is not handled, the default behavior is to show the content of the +-- requested URI if WebKit can show this MIME type and the content disposition is not a download; +-- if WebKit is not able to show the MIME type nothing happens. +-- +-- Notice that if you return True, meaning that you handled the signal, +-- you are expected to be aware of the "Content-Disposition" header. +-- A value of "attachment" usually indicates a download regardless of the MIME type, +-- see also soupMessageHeadersGetContentDisposition' +-- And you must call 'webPolicyDecisionIgnore', 'webPolicyDecisionDownload', or 'webPolicyDecisionUse' +-- on the 'webPolicyDecision' object. +mimeTypePolicyDecisionRequested :: (WebViewClass self, GlibString string) => Signal self (WebFrame -> NetworkRequest -> string -> WebPolicyDecision -> IO Bool) +mimeTypePolicyDecisionRequested = Signal (connect_OBJECT_OBJECT_GLIBSTRING_OBJECT__BOOL "mime_type_policy_decision_requested") + +-- | The 'moveCursor' will be emitted to apply the cursor movement described by its parameters to the view. +moveCursor :: WebViewClass self => Signal self (MovementStep -> Int -> IO Bool) +moveCursor = Signal (connect_ENUM_INT__BOOL "move_cursor") + +-- | Emitted when frame requests a navigation to another page. +-- If this signal is not handled, the default behavior is to allow the navigation. +-- +-- Notice that if you return True, meaning that you handled the signal, +-- you are expected to be aware of the "Content-Disposition" header. +-- A value of "attachment" usually indicates a download regardless of the MIME type, +-- see also soupMessageHeadersGetContentDisposition' +-- And you must call 'webPolicyDecisionIgnore', 'webPolicyDecisionDownload', or 'webPolicyDecisionUse' +-- on the 'webPolicyDecision' object. +navigationPolicyDecisionRequested :: WebViewClass self => Signal self (WebFrame -> NetworkRequest -> WebNavigationAction -> WebPolicyDecision -> IO Bool) +navigationPolicyDecisionRequested = Signal (connect_OBJECT_OBJECT_OBJECT_OBJECT__BOOL "navigation_policy_decision_requested") + +-- | Emitted when frame requests opening a new window. +-- With this signal the browser can use the context of the request to decide about the new window. +-- If the request is not handled the default behavior is to allow opening the new window to load the URI, +-- which will cause a 'createWebView' signal emission where the browser handles the new window action +-- but without information of the context that caused the navigation. +-- The following 'navigationPolicyDecisionRequested' emissions will load the page +-- after the creation of the new window just with the information of this new navigation context, +-- without any information about the action that made this new window to be opened. +-- +-- Notice that if you return True, meaning that you handled the signal, +-- you are expected to be aware of the "Content-Disposition" header. +-- A value of "attachment" usually indicates a download regardless of the MIME type, +-- see also soupMessageHeadersGetContentDisposition' +-- And you must call 'webPolicyDecisionIgnore', 'webPolicyDecisionDownload', or 'webPolicyDecisionUse' +-- on the 'webPolicyDecision' object. +newWindowPolicyDecisionRequested :: WebViewClass self => Signal self (WebFrame -> NetworkRequest -> WebNavigationAction -> WebPolicyDecision -> IO Bool) +newWindowPolicyDecisionRequested = Signal (connect_OBJECT_OBJECT_OBJECT_OBJECT__BOOL "new_window_policy_decision_requested") + +-- | Emitted when a request is about to be sent. +-- You can modify the request while handling this signal. +-- You can set the URI in the 'NetworkRequest' object itself, +-- and add/remove/replace headers using the SoupMessage object it carries, +-- if it is present. See 'networkRequestGetMessage'. +-- Setting the request URI to "about:blank" will effectively cause the request to load nothing, +-- and can be used to disable the loading of specific resources. +-- +-- Notice that information about an eventual redirect is available in response's SoupMessage, +-- not in the SoupMessage carried by the request. +-- If response is NULL, then this is not a redirected request. +-- +-- The 'WebResource' object will be the same throughout all the lifetime of the resource, +-- but the contents may change from inbetween signal emissions. +resourceRequestStarting :: WebViewClass self => Signal self (WebFrame -> WebResource -> Maybe NetworkRequest -> Maybe NetworkResponse -> IO ()) +resourceRequestStarting = Signal (connect_OBJECT_OBJECT_MOBJECT_MOBJECT__NONE "resource_request_starting") + +#if WEBKIT_CHECK_VERSION (1,1,23) +-- | When a frame wants to cancel geolocation permission it had requested before. +-- +-- * Since 1.1.23 +geolocationPolicyDecisionCancelled :: WebViewClass self => Signal self (WebFrame -> IO ()) +geolocationPolicyDecisionCancelled = Signal (connect_OBJECT__NONE "geolocation_policy_decision_cancelled") + +-- | When a frame wants to get its geolocation permission. The receiver must reply with a boolean wether +-- it handled or not the request. If the request is not handled, default behaviour is to deny +-- geolocation. +-- +-- * Since 1.1.23 +geolocationPolicyDecisionRequested :: WebViewClass self => Signal self (WebFrame -> GeolocationPolicyDecision -> IO Bool) +geolocationPolicyDecisionRequested = Signal (connect_OBJECT_OBJECT__BOOL "geolocation_policy_decision_requested") #endif diff --git a/Graphics/UI/Gtk/WebKit/WebWindowFeatures.chs b/Graphics/UI/Gtk/WebKit/WebWindowFeatures.chs --- a/Graphics/UI/Gtk/WebKit/WebWindowFeatures.chs +++ b/Graphics/UI/Gtk/WebKit/WebWindowFeatures.chs @@ -29,7 +29,7 @@ -- include the x, y position of the window, the width and height but also if a toolbar, scrollbar, -- statusbar, locationbar should be visible to the user, the request to show the WebKitWebView -- fullscreen. --- +-- -- In the normal case one will use 'webViewGetWindowFeatures' to get the -- WebKitWebWindowFeatures and then monitor the property changes. Be aware that the -- WebKitWebWindowFeatures might change change before 'webViewReady' signal is emitted. To be safe @@ -43,7 +43,7 @@ -- * Constructors webWindowFeaturesNew, --- * Methods +-- * Methods webWindowFeaturesEqual, -- * Attributes @@ -64,8 +64,8 @@ import System.Glib.FFI import System.Glib.UTFString import System.Glib.GList -import System.Glib.GError -import System.Glib.Attributes +import System.Glib.GError +import System.Glib.Attributes as G import System.Glib.Properties import Graphics.UI.Gtk.Gdk.Events @@ -77,14 +77,14 @@ -- * Constructors --- | Creates a new 'WebWindowFeatures' instance with default values. +-- | Creates a new 'WebWindowFeatures' instance with default values. -- It must be manually attached to a WebView. webWindowFeaturesNew :: IO WebWindowFeatures -webWindowFeaturesNew = +webWindowFeaturesNew = wrapNewGObject mkWebWindowFeatures $ {#call web_window_features_new#} -- | Decides if a 'WebWindowFeatures' instance equals another, as in has the same values. -webWindowFeaturesEqual :: +webWindowFeaturesEqual :: (WebWindowFeaturesClass winA, WebWindowFeaturesClass winB) => winA -> winB -> IO Bool webWindowFeaturesEqual winA winB = @@ -93,42 +93,42 @@ -- * Attributes -- | Controls whether window will be displayed fullscreen. -webWindowFeaturesFullscreen :: WebWindowFeaturesClass self => Attr self Bool +webWindowFeaturesFullscreen :: WebWindowFeaturesClass self => G.Attr self Bool webWindowFeaturesFullscreen = newAttrFromBoolProperty "fullscreen" -- | The height of the window on the screen. -webWindowFeaturesHeight :: WebWindowFeaturesClass self => Attr self Int +webWindowFeaturesHeight :: WebWindowFeaturesClass self => G.Attr self Int webWindowFeaturesHeight = newAttrFromIntProperty "height" -- | The width of the window on the screen. -webWindowFeaturesWidth :: WebWindowFeaturesClass self => Attr self Int +webWindowFeaturesWidth :: WebWindowFeaturesClass self => G.Attr self Int webWindowFeaturesWidth = newAttrFromIntProperty "width" -- | Controls whether the locationbar should be visible for the window. -webWindowFeaturesLocationbarVisible :: WebWindowFeaturesClass self => Attr self Bool +webWindowFeaturesLocationbarVisible :: WebWindowFeaturesClass self => G.Attr self Bool webWindowFeaturesLocationbarVisible = newAttrFromBoolProperty "locationbar-visible" -- | Controls whether the menubar should be visible for the window. -webWindowFeaturesMenubarVisible :: WebWindowFeaturesClass self => Attr self Bool +webWindowFeaturesMenubarVisible :: WebWindowFeaturesClass self => G.Attr self Bool webWindowFeaturesMenubarVisible = newAttrFromBoolProperty "menubar-visible" -- | Controls whether the scrollbar should be visible for the window. -webWindowFeaturesScrollbarVisible :: WebWindowFeaturesClass self => Attr self Bool +webWindowFeaturesScrollbarVisible :: WebWindowFeaturesClass self => G.Attr self Bool webWindowFeaturesScrollbarVisible = newAttrFromBoolProperty "scrollbar-visible" -- | Controls whether the statusbar should be visible for the window. -webWindowFeaturesStatusbarVisible :: WebWindowFeaturesClass self => Attr self Bool +webWindowFeaturesStatusbarVisible :: WebWindowFeaturesClass self => G.Attr self Bool webWindowFeaturesStatusbarVisible = newAttrFromBoolProperty "statusbar-visible" -- | Controls whether the toolbar should be visible for the window. -webWindowFeaturesToolbarVisible :: WebWindowFeaturesClass self => Attr self Bool +webWindowFeaturesToolbarVisible :: WebWindowFeaturesClass self => G.Attr self Bool webWindowFeaturesToolbarVisible = newAttrFromBoolProperty "toolbar-visible" -- | The starting x position of the window on the screen. -webWindowFeaturesX :: WebWindowFeaturesClass self => Attr self Int +webWindowFeaturesX :: WebWindowFeaturesClass self => G.Attr self Int webWindowFeaturesX = newAttrFromIntProperty "x" -- | The starting y position of the window on the screen. -webWindowFeaturesY :: WebWindowFeaturesClass self => Attr self Int +webWindowFeaturesY :: WebWindowFeaturesClass self => G.Attr self Int webWindowFeaturesY = newAttrFromIntProperty "y" diff --git a/Gtk2HsSetup.hs b/Gtk2HsSetup.hs deleted file mode 100644 --- a/Gtk2HsSetup.hs +++ /dev/null @@ -1,511 +0,0 @@ -{-# LANGUAGE CPP #-} - -#define CABAL_VERSION_ENCODE(major, minor, micro) ( \ - ((major) * 10000) \ - + ((minor) * 100) \ - + ((micro) * 1)) - -#define CABAL_VERSION_CHECK(major,minor,micro) \ - (CABAL_VERSION >= CABAL_VERSION_ENCODE(major,minor,micro)) - --- now, this is bad, but Cabal doesn't seem to actually pass any information about --- its version to CPP, so guess the version depending on the version of GHC -#ifdef CABAL_VERSION_MINOR -#ifndef CABAL_VERSION_MAJOR -#define CABAL_VERSION_MAJOR 1 -#endif -#ifndef CABAL_VERSION_MICRO -#define CABAL_VERSION_MICRO 0 -#endif -#define CABAL_VERSION CABAL_VERSION_ENCODE( \ - CABAL_VERSION_MAJOR, \ - CABAL_VERSION_MINOR, \ - CABAL_VERSION_MICRO) -#else -#warning Setup.hs is guessing the version of Cabal. If compilation of Setup.hs fails use -DCABAL_VERSION_MINOR=x for Cabal version 1.x.0 when building (prefixed by --ghc-option= when using the 'cabal' command) -#if (__GLASGOW_HASKELL__ >= 700) -#define CABAL_VERSION CABAL_VERSION_ENCODE(1,10,0) -#else -#if (__GLASGOW_HASKELL__ >= 612) -#define CABAL_VERSION CABAL_VERSION_ENCODE(1,8,0) -#else -#define CABAL_VERSION CABAL_VERSION_ENCODE(1,6,0) -#endif -#endif -#endif - --- | Build a Gtk2hs package. --- -module Gtk2HsSetup ( - gtk2hsUserHooks, - getPkgConfigPackages, - checkGtk2hsBuildtools - ) where - -import Distribution.Simple -import Distribution.Simple.PreProcess -import Distribution.InstalledPackageInfo ( importDirs, - showInstalledPackageInfo, - libraryDirs, - extraLibraries, - extraGHCiLibraries ) -import Distribution.Simple.PackageIndex ( -#if CABAL_VERSION_CHECK(1,8,0) - lookupInstalledPackageId -#else - lookupPackageId -#endif - ) -import Distribution.PackageDescription as PD ( PackageDescription(..), - updatePackageDescription, - BuildInfo(..), - emptyBuildInfo, allBuildInfo, - Library(..), - libModules, hasLibs) -import Distribution.Simple.LocalBuildInfo (LocalBuildInfo(..), - InstallDirs(..), -#if CABAL_VERSION_CHECK(1,8,0) - componentPackageDeps, -#else - packageDeps, -#endif - absoluteInstallDirs) -import Distribution.Simple.Compiler ( Compiler(..) ) -import Distribution.Simple.Program ( - Program(..), ConfiguredProgram(..), - rawSystemProgramConf, rawSystemProgramStdoutConf, programName, - c2hsProgram, pkgConfigProgram, requireProgram, ghcPkgProgram, - simpleProgram, lookupProgram, rawSystemProgramStdout, ProgArg) -import Distribution.ModuleName ( ModuleName, components, toFilePath ) -import Distribution.Simple.Utils -import Distribution.Simple.Setup (CopyFlags(..), InstallFlags(..), CopyDest(..), - defaultCopyFlags, ConfigFlags(configVerbosity), - fromFlag, toFlag, RegisterFlags(..), flagToMaybe, - fromFlagOrDefault, defaultRegisterFlags) -import Distribution.Simple.BuildPaths ( autogenModulesDir ) -import Distribution.Simple.Install ( install ) -#if CABAL_VERSION_CHECK(1,8,0) -import Distribution.Simple.Register ( generateRegistrationInfo, registerPackage ) -#else -import qualified Distribution.Simple.Register as Register ( register ) -#endif -import Distribution.Text ( simpleParse, display ) -import System.FilePath -import System.Exit (exitFailure) -import System.Directory ( doesFileExist, getDirectoryContents, doesDirectoryExist ) -import Distribution.Version (Version(..)) -import Distribution.Verbosity -import Control.Monad (when, unless, filterM, liftM, forM, forM_) -import Data.Maybe ( isJust, isNothing, fromMaybe, maybeToList ) -import Data.List (isPrefixOf, isSuffixOf, nub) -import Data.Char (isAlpha) -import qualified Data.Map as M -import qualified Data.Set as S - -import Control.Applicative ((<$>)) - --- the name of the c2hs pre-compiled header file -precompFile = "precompchs.bin" - -gtk2hsUserHooks = simpleUserHooks { - hookedPrograms = [typeGenProgram, signalGenProgram, c2hsLocal], - hookedPreProcessors = [("chs", ourC2hs)], - confHook = \pd cf -> - (fmap adjustLocalBuildInfo (confHook simpleUserHooks pd cf)), - postConf = \args cf pd lbi -> do - genSynthezisedFiles (fromFlag (configVerbosity cf)) pd lbi - postConf simpleUserHooks args cf pd lbi, - buildHook = \pd lbi uh bf -> fixDeps pd >>= \pd -> - buildHook simpleUserHooks pd lbi uh bf, - copyHook = \pd lbi uh flags -> copyHook simpleUserHooks pd lbi uh flags >> - installCHI pd lbi (fromFlag (copyVerbosity flags)) (fromFlag (copyDest flags)), - instHook = \pd lbi uh flags -> -#if defined(mingw32_HOST_OS) || defined(__MINGW32__) - installHook pd lbi uh flags >> - installCHI pd lbi (fromFlag (installVerbosity flags)) NoCopyDest, - regHook = registerHook -#else - instHook simpleUserHooks pd lbi uh flags >> - installCHI pd lbi (fromFlag (installVerbosity flags)) NoCopyDest -#endif - } - ------------------------------------------------------------------------------- --- Lots of stuff for windows ghci support ------------------------------------------------------------------------------- - -getDlls :: [FilePath] -> IO [FilePath] -getDlls dirs = filter ((== ".dll") . takeExtension) . concat <$> - mapM getDirectoryContents dirs - -fixLibs :: [FilePath] -> [String] -> [String] -fixLibs dlls = concatMap $ \ lib -> - case filter (("lib" ++ lib) `isPrefixOf`) dlls of - dll:_ -> [dropExtension dll] - _ -> if lib == "z" then [] else [lib] - --- The following code is a big copy-and-paste job from the sources of --- Cabal 1.8 just to be able to fix a field in the package file. Yuck. - -#if CABAL_VERSION_CHECK(1,8,0) - -installHook :: PackageDescription -> LocalBuildInfo - -> UserHooks -> InstallFlags -> IO () -installHook pkg_descr localbuildinfo _ flags = do - let copyFlags = defaultCopyFlags { - copyDistPref = installDistPref flags, - copyDest = toFlag NoCopyDest, - copyVerbosity = installVerbosity flags - } - install pkg_descr localbuildinfo copyFlags - let registerFlags = defaultRegisterFlags { - regDistPref = installDistPref flags, - regInPlace = installInPlace flags, - regPackageDB = installPackageDB flags, - regVerbosity = installVerbosity flags - } - when (hasLibs pkg_descr) $ register pkg_descr localbuildinfo registerFlags - -registerHook :: PackageDescription -> LocalBuildInfo - -> UserHooks -> RegisterFlags -> IO () -registerHook pkg_descr localbuildinfo _ flags = - if hasLibs pkg_descr - then register pkg_descr localbuildinfo flags - else setupMessage verbosity - "Package contains no library to register:" (packageId pkg_descr) - where verbosity = fromFlag (regVerbosity flags) - -register :: PackageDescription -> LocalBuildInfo - -> RegisterFlags -- ^Install in the user's database?; verbose - -> IO () -register pkg@PackageDescription { library = Just lib } - lbi@LocalBuildInfo { libraryConfig = Just clbi } regFlags - = do - - installedPkgInfoRaw <- generateRegistrationInfo - verbosity pkg lib lbi clbi inplace distPref - - dllsInScope <- getSearchPath >>= (filterM doesDirectoryExist) >>= getDlls - let libs = fixLibs dllsInScope (extraLibraries installedPkgInfoRaw) - installedPkgInfo = installedPkgInfoRaw { - extraGHCiLibraries = libs } - - -- Three different modes: - case () of - _ | modeGenerateRegFile -> die "Generate Reg File not supported" - | modeGenerateRegScript -> die "Generate Reg Script not supported" - | otherwise -> registerPackage verbosity -#if CABAL_VERSION_CHECK(1,10,0) - installedPkgInfo pkg lbi inplace [packageDb] -#else - installedPkgInfo pkg lbi inplace packageDb -#endif - - where - modeGenerateRegFile = isJust (flagToMaybe (regGenPkgConf regFlags)) - modeGenerateRegScript = fromFlag (regGenScript regFlags) - inplace = fromFlag (regInPlace regFlags) - packageDb = case flagToMaybe (regPackageDB regFlags) of - Just db -> db - Nothing -> registrationPackageDB (withPackageDB lbi) - distPref = fromFlag (regDistPref regFlags) - verbosity = fromFlag (regVerbosity regFlags) - -register _ _ regFlags = notice verbosity "No package to register" - where - verbosity = fromFlag (regVerbosity regFlags) - -#else -installHook :: PackageDescription -> LocalBuildInfo - -> UserHooks -> InstallFlags -> IO () -installHook pkg_descr localbuildinfo _ flags = do - let copyFlags = defaultCopyFlags { - copyDistPref = installDistPref flags, - copyInPlace = installInPlace flags, - copyUseWrapper = installUseWrapper flags, - copyDest = toFlag NoCopyDest, - copyVerbosity = installVerbosity flags - } - install pkg_descr localbuildinfo copyFlags - let registerFlags = defaultRegisterFlags { - regDistPref = installDistPref flags, - regInPlace = installInPlace flags, - regPackageDB = installPackageDB flags, - regVerbosity = installVerbosity flags - } - when (hasLibs pkg_descr) $ register pkg_descr localbuildinfo registerFlags - -registerHook :: PackageDescription -> LocalBuildInfo - -> UserHooks -> RegisterFlags -> IO () -registerHook pkg_descr localbuildinfo _ flags = - if hasLibs pkg_descr - then register pkg_descr localbuildinfo flags - else setupMessage verbosity - "Package contains no library to register:" (packageId pkg_descr) - where verbosity = fromFlag (regVerbosity flags) - -register :: PackageDescription -> LocalBuildInfo - -> RegisterFlags -- ^Install in the user's database?; verbose - -> IO () -register pkg_descr lbi regFlags = do - let verbosity = fromFlag (regVerbosity regFlags) - warn verbosity "Cannot register ghci libraries with Cabal 1.6 (need 1.8)." - Register.register pkg_descr lbi regFlags - -#endif - ------------------------------------------------------------------------------- --- This is a hack for Cabal-1.8, It is not needed in Cabal-1.9.1 or later ------------------------------------------------------------------------------- - -adjustLocalBuildInfo :: LocalBuildInfo -> LocalBuildInfo -adjustLocalBuildInfo lbi = - let extra = (Just libBi, []) - libBi = emptyBuildInfo { includeDirs = [ autogenModulesDir lbi - , buildDir lbi ] } - in lbi { localPkgDescr = updatePackageDescription extra (localPkgDescr lbi) } - ------------------------------------------------------------------------------- --- Processing .chs files with our local c2hs. ------------------------------------------------------------------------------- - -ourC2hs :: BuildInfo -> LocalBuildInfo -> PreProcessor -ourC2hs bi lbi = PreProcessor { - platformIndependent = False, - runPreProcessor = runC2HS bi lbi -} - -runC2HS :: BuildInfo -> LocalBuildInfo -> - (FilePath, FilePath) -> (FilePath, FilePath) -> Verbosity -> IO () -runC2HS bi lbi (inDir, inFile) (outDir, outFile) verbosity = do - -- have the header file name if we don't have the precompiled header yet - header <- case lookup "x-c2hs-header" (customFieldsBI bi) of - Just h -> return h - Nothing -> die ("Need x-c2hs-Header definition in the .cabal Library section "++ - "that sets the C header file to process .chs.pp files.") - - -- c2hs will output files in out dir, removing any leading path of the input file. - -- Thus, append the dir of the input file to the output dir. - let (outFileDir, newOutFile) = splitFileName outFile - let newOutDir = outDir outFileDir - -- additional .chi files might be needed that other packages have installed; - -- we assume that these are installed in the same place as .hi files - let chiDirs = [ dir | -#if CABAL_VERSION_CHECK(1,8,0) - ipi <- maybe [] (map fst . componentPackageDeps) (libraryConfig lbi), - dir <- maybe [] importDirs (lookupInstalledPackageId (installedPkgs lbi) ipi) ] -#else - ipi <- packageDeps lbi, - dir <- maybe [] importDirs (lookupPackageId (installedPkgs lbi) ipi) ] -#endif - rawSystemProgramConf verbosity c2hsLocal (withPrograms lbi) $ - map ("--include=" ++) (outDir:chiDirs) - ++ ["--cppopts=" ++ opt | opt <- getCppOptions bi lbi] - ++ ["--output-dir=" ++ newOutDir, - "--output=" ++ newOutFile, - "--precomp=" ++ buildDir lbi precompFile, - header, inDir inFile] - -getCppOptions :: BuildInfo -> LocalBuildInfo -> [String] -getCppOptions bi lbi - = nub $ - ["-I" ++ dir | dir <- PD.includeDirs bi] - ++ [opt | opt@('-':c:_) <- PD.cppOptions bi ++ PD.ccOptions bi, c `elem` "DIU"] - -installCHI :: PackageDescription -- ^information from the .cabal file - -> LocalBuildInfo -- ^information from the configure step - -> Verbosity -> CopyDest -- ^flags sent to copy or install - -> IO () -installCHI pkg@PD.PackageDescription { library = Just lib } lbi verbosity copydest = do - let InstallDirs { libdir = libPref } = absoluteInstallDirs pkg lbi copydest - -- cannot use the recommended 'findModuleFiles' since it fails if there exists - -- a modules that does not have a .chi file - mFiles <- mapM (findFileWithExtension' ["chi"] [buildDir lbi] . toFilePath) -#if CABAL_VERSION_CHECK(1,8,0) - (PD.libModules lib) -#else - (PD.libModules pkg) -#endif - - let files = [ f | Just f <- mFiles ] -#if CABAL_VERSION_CHECK(1,8,0) - installOrdinaryFiles verbosity libPref files -#else - copyFiles verbosity libPref files -#endif - - -installCHI _ _ _ _ = return () - ------------------------------------------------------------------------------- --- Generating the type hierarchy and signal callback .hs files. ------------------------------------------------------------------------------- - -typeGenProgram :: Program -typeGenProgram = simpleProgram "gtk2hsTypeGen" - -signalGenProgram :: Program -signalGenProgram = simpleProgram "gtk2hsHookGenerator" - -c2hsLocal :: Program -c2hsLocal = simpleProgram "gtk2hsC2hs" - -genSynthezisedFiles :: Verbosity -> PackageDescription -> LocalBuildInfo -> IO () -genSynthezisedFiles verb pd lbi = do - - cPkgs <- getPkgConfigPackages verb lbi pd - - let xList = maybe [] (customFieldsBI . libBuildInfo) (library pd) - ++customFieldsPD pd - typeOpts :: String -> [ProgArg] - typeOpts tag = concat [ map (\val -> '-':'-':drop (length tag) field++'=':val) (words content) - | (field,content) <- xList, - tag `isPrefixOf` field, - field /= (tag++"file")] - ++ [ "--tag=" ++ tag - | PackageIdentifier name (Version (major:minor:_) _) <- cPkgs - , let name' = filter isAlpha (display name) - , tag <- name' - : [ name' ++ "-" ++ show major ++ "." ++ show digit - | digit <- [0,2..minor] ] - ] - - signalsOpts :: [ProgArg] - signalsOpts = concat [ map (\val -> '-':'-':drop 10 field++'=':val) (words content) - | (field,content) <- xList, - "x-signals-" `isPrefixOf` field, - field /= "x-signals-file"] - - genFile :: Program -> [ProgArg] -> FilePath -> IO () - genFile prog args outFile = do - res <- rawSystemProgramStdoutConf verb prog (withPrograms lbi) args - rewriteFile outFile res - - forM_ (filter (\(tag,_) -> "x-types-" `isPrefixOf` tag && "file" `isSuffixOf` tag) xList) $ - \(fileTag, f) -> do - let tag = reverse (drop 4 (reverse fileTag)) - info verb ("Ensuring that class hierarchy in "++f++" is up-to-date.") - genFile typeGenProgram (typeOpts tag) f - - case lookup "x-signals-file" xList of - Nothing -> return () - Just f -> do - info verb ("Ensuring that callback hooks in "++f++" are up-to-date.") - genFile signalGenProgram signalsOpts f - ---FIXME: Cabal should tell us the selected pkg-config package versions in the --- LocalBuildInfo or equivalent. --- In the mean time, ask pkg-config again. - -getPkgConfigPackages :: Verbosity -> LocalBuildInfo -> PackageDescription -> IO [PackageId] -getPkgConfigPackages verbosity lbi pkg = - sequence - [ do version <- pkgconfig ["--modversion", display pkgname] - case simpleParse version of - Nothing -> die "parsing output of pkg-config --modversion failed" - Just v -> return (PackageIdentifier pkgname v) - | Dependency pkgname _ <- concatMap pkgconfigDepends (allBuildInfo pkg) ] - where - pkgconfig = rawSystemProgramStdoutConf verbosity - pkgConfigProgram (withPrograms lbi) - ------------------------------------------------------------------------------- --- Dependency calculation amongst .chs files. ------------------------------------------------------------------------------- - --- Given all files of the package, find those that end in .chs and extract the --- .chs files they depend upon. Then return the PackageDescription with these --- files rearranged so that they are built in a sequence that files that are --- needed by other files are built first. -fixDeps :: PackageDescription -> IO PackageDescription -fixDeps pd@PD.PackageDescription { - PD.library = Just lib@PD.Library { - PD.exposedModules = expMods, - PD.libBuildInfo = bi@PD.BuildInfo { - PD.hsSourceDirs = srcDirs, - PD.otherModules = othMods - }}} = do - let findModule m = findFileWithExtension [".chs.pp",".chs"] srcDirs - (joinPath (components m)) - mExpFiles <- mapM findModule expMods - mOthFiles <- mapM findModule othMods - - -- tag all exposed files with True so we throw an error if we need to build - -- an exposed module before an internal modules (we cannot express this) - let modDeps = zipWith (ModDep True []) expMods mExpFiles++ - zipWith (ModDep False []) othMods mOthFiles - modDeps <- mapM extractDeps modDeps - let (expMods, othMods) = span mdExposed $ sortTopological modDeps - badOther = map (fromMaybe "" . mdLocation) $ - filter (not . mdExposed) expMods - unless (null badOther) $ - die ("internal chs modules "++intercalate "," badOther++ - " depend on exposed chs modules; cabal needs to build internal modules first") - return pd { PD.library = Just lib { - PD.exposedModules = map mdOriginal expMods, - PD.libBuildInfo = bi { PD.otherModules = map mdOriginal othMods } - }} - -data ModDep = ModDep { - mdExposed :: Bool, - mdRequires :: [ModuleName], - mdOriginal :: ModuleName, - mdLocation :: Maybe FilePath -} - -instance Show ModDep where - show x = show (mdLocation x) - -instance Eq ModDep where - ModDep { mdOriginal = m1 } == ModDep { mdOriginal = m2 } = m1==m2 -instance Ord ModDep where - compare ModDep { mdOriginal = m1 } ModDep { mdOriginal = m2 } = compare m1 m2 - --- Extract the dependencies of this file. This is intentionally rather naive as it --- ignores CPP conditionals. We just require everything which means that the --- existance of a .chs module may not depend on some CPP condition. -extractDeps :: ModDep -> IO ModDep -extractDeps md@ModDep { mdLocation = Nothing } = return md -extractDeps md@ModDep { mdLocation = Just f } = withUTF8FileContents f $ \con -> do - let findImports acc (('{':'#':xs):xxs) = case (dropWhile (' ' ==) xs) of - ('i':'m':'p':'o':'r':'t':' ':ys) -> - case simpleParse (takeWhile ('#' /=) ys) of - Just m -> findImports (m:acc) xxs - Nothing -> die ("cannot parse chs import in "++f++":\n"++ - "offending line is {#"++xs) - -- no more imports after the first non-import hook - _ -> return acc - findImports acc (_:xxs) = findImports acc xxs - findImports acc [] = return acc - mods <- findImports [] (lines con) - return md { mdRequires = mods } - --- Find a total order of the set of modules that are partially sorted by their --- dependencies on each other. The function returns the sorted list of modules --- together with a list of modules that are required but not supplied by this --- in the input set of modules. -sortTopological :: [ModDep] -> [ModDep] -sortTopological ms = reverse $ fst $ foldl visit ([], S.empty) (map mdOriginal ms) - where - set = M.fromList (map (\m -> (mdOriginal m, m)) ms) - visit (out,visited) m - | m `S.member` visited = (out,visited) - | otherwise = case m `M.lookup` set of - Nothing -> (out, m `S.insert` visited) - Just md -> (md:out', visited') - where - (out',visited') = foldl visit (out, m `S.insert` visited) (mdRequires md) - --- Check user whether install gtk2hs-buildtools correctly. -checkGtk2hsBuildtools :: [String] -> IO () -checkGtk2hsBuildtools programs = do - programInfos <- mapM (\ name -> do - location <- programFindLocation (simpleProgram name) normal - return (name, location) - ) programs - let printError name = do - putStrLn $ "Cannot find " ++ name ++ "\n" - ++ "Please install `gtk2hs-buildtools` first and check that the install directory is in your PATH (e.g. HOME/.cabal/bin)." - exitFailure - forM_ programInfos $ \ (name, location) -> - when (isNothing location) (printError name) diff --git a/Setup.hs b/Setup.hs --- a/Setup.hs +++ b/Setup.hs @@ -1,10 +1,12 @@ --- Setup file for a Gtk2Hs module. Contains only adjustments specific to this module, --- all Gtk2Hs-specific boilerplate is stored in Gtk2HsSetup.hs which should be kept --- identical across all modules. -import Gtk2HsSetup ( gtk2hsUserHooks, checkGtk2hsBuildtools ) +-- Adjustments specific to this package, +-- all Gtk2Hs-specific boilerplate is kept in +-- gtk2hs-buildtools:Gtk2HsSetup +-- +import Gtk2HsSetup ( gtk2hsUserHooks, checkGtk2hsBuildtools, + typeGenProgram, signalGenProgram, c2hsLocal) import Distribution.Simple ( defaultMainWithHooks ) main = do - checkGtk2hsBuildtools ["gtk2hsC2hs", "gtk2hsTypeGen", "gtk2hsHookGenerator"] + checkGtk2hsBuildtools [typeGenProgram, signalGenProgram, c2hsLocal] defaultMainWithHooks gtk2hsUserHooks - + diff --git a/cbits/events.h b/cbits/events.h new file mode 100644 --- /dev/null +++ b/cbits/events.h @@ -0,0 +1,20 @@ +#include +#include + +#if WEBKIT_CHECK_VERSION(2,0,0) + #include +#else + #include +#endif + +gboolean webkit_dom_event_target_add_event_listener_closure( + WebKitDOMEventTarget *target, + const char *eventName, + GClosure *closure, + gboolean bubble); + +gboolean webkit_dom_event_target_remove_event_listener_closure( + WebKitDOMEventTarget *target, + const char *eventName, + GClosure *closure, + gboolean bubble); diff --git a/cbits/hsgclosure.h b/cbits/hsgclosure.h new file mode 100644 --- /dev/null +++ b/cbits/hsgclosure.h @@ -0,0 +1,22 @@ +/* GIMP Toolkit (GTK) HSGClosure interface + * + * Author : Duncan Coutts + * + * Created: 22 March 2005 + * + * Copyright (C) 2005 Duncan Coutts + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + */ + +#include + +GClosure * gtk2hs_closure_new(HsStablePtr callback); diff --git a/demo/Webkit.hs b/demo/Webkit.hs --- a/demo/Webkit.hs +++ b/demo/Webkit.hs @@ -14,13 +14,17 @@ -- module Main where -import Graphics.UI.Gtk -import Graphics.UI.Gtk.WebKit.WebView -import Graphics.UI.Gtk.WebKit.WebFrame +import Control.Monad.Trans -import System.Process -import System.Environment +import Data.Text +import Graphics.UI.Gtk +import Graphics.UI.Gtk.WebKit.WebFrame +import Graphics.UI.Gtk.WebKit.WebView + +import System.Environment +import System.Process + -- | Main entry. main :: IO () main = do @@ -46,7 +50,7 @@ window <- windowNew windowSetDefaultSize window 900 600 windowSetPosition window WinPosCenter - windowSetOpacity window 0.8 -- this function need window-manager support Alpha channel in X11 + set window [windowOpacity := 0.8] -- this function need window-manager support Alpha channel in X11 -- Create WebKit view. webView <- webViewNew @@ -65,23 +69,23 @@ entrySetText addressBar url -- Open uri when user press `return` at address bar. - onEntryActivate addressBar $ do - uri <- entryGetText addressBar -- get uri from address bar - webViewLoadUri webView uri -- load new uri + addressBar `on` entryActivated $ do + uri <- entryGetText addressBar -- get uri from address bar + webViewLoadUri webView (uri :: Text) -- load new uri - -- Add current uri to address bar when load start. - webView `on` loadStarted $ \frame -> do + -- Add current uri to address bar when load is committed. + webView `on` loadCommitted $ \frame -> do currentUri <- webFrameGetUri frame case currentUri of - Just uri -> entrySetText addressBar uri - Nothing -> return () + Just uri -> entrySetText addressBar (uri :: Text) + _ -> return () -- Open all link in current window. webView `on` createWebView $ \frame -> do newUri <- webFrameGetUri frame case newUri of - Just uri -> webViewLoadUri webView uri - Nothing -> return () + Just uri -> webViewLoadUri webView (uri :: Text) + _ -> return () return webView -- Connect and show. @@ -89,7 +93,7 @@ boxPackStart winBox scrollWin PackGrow 0 window `containerAdd` winBox scrollWin `containerAdd` webView - window `onDestroy` mainQuit + window `on` deleteEvent $ lift mainQuit >> return True widgetShowAll window mainGUI diff --git a/hierarchy.list b/hierarchy.list --- a/hierarchy.list +++ b/hierarchy.list @@ -340,3 +340,148 @@ 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 + WebKitDOMDOMImplementation as DOMImplementation, webkit_dom_dom_implementation_get_type if webkit-dom + WebKitDOMDOMNamedFlowCollection as DOMNamedFlowCollection, webkit_dom_dom_named_flow_collection_get_type if webkit-2.2 + 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 + WebKitDOMEvent as Event, webkit_dom_event_get_type if webkit-dom + WebKitDOMUIEvent as UIEvent, webkit_dom_ui_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 + 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 + 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 + 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 + 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 + WebKitDOMXPathResult as XPathResult, webkit_dom_xpath_result_get_type if webkit-dom diff --git a/hswebkit.h b/hswebkit.h --- a/hswebkit.h +++ b/hswebkit.h @@ -17,11 +17,104 @@ * Boston, MA 02110-1301, USA. */ +#ifdef __BLOCKS__ +#undef __BLOCKS__ +#endif + #ifndef HS_WEBKIT_H #define HS_WEBKIT_H /* to avoid stdbool.h error in JavaScriptCore/JSBase.h*/ #define _Bool int +#define WINAPI +#define CALLBACK + /* include webkit headers*/ #include +#include #endif + +#include "events.h" + +#undef Bool +#undef True +#undef False +#undef true +#undef false +#undef Button1 +#undef Button2 +#undef Button3 +#undef Button4 +#undef Button5 +#undef Button1Mask +#undef Button2Mask +#undef Button3Mask +#undef Button4Mask +#undef Button5Mask + +#undef ShiftMask +#undef LockMask +#undef ControlMask +#undef Mod1Mask +#undef Mod2Mask +#undef Mod3Mask +#undef Mod4Mask +#undef Mod5Mask + +#undef None +#undef ParentRelative +#undef CopyFromParent +#undef PointerWindow +#undef InputFocus +#undef PointerRoot +#undef AnyPropertyType +#undef AnyKey +#undef AnyButton +#undef AllTemporary +#undef CurrentTime +#undef NoSymbol + +#undef NoEventMask +#undef KeyPressMask +#undef KeyReleaseMask +#undef ButtonPressMask +#undef ButtonReleaseMask +#undef EnterWindowMask +#undef LeaveWindowMask +#undef PointerMotionMask +#undef PointerMotionHintMask +#undef Button1MotionMask +#undef Button2MotionMask +#undef Button3MotionMask +#undef Button4MotionMask +#undef Button5MotionMask +#undef ButtonMotionMask +#undef KeymapStateMask +#undef ExposureMask +#undef VisibilityChangeMask +#undef StructureNotifyMask +#undef ResizeRedirectMask +#undef SubstructureNotifyMask +#undef SubstructureRedirectMask +#undef FocusChangeMask +#undef PropertyChangeMask +#undef ColormapChangeMask +#undef OwnerGrabButtonMask +#undef Status +#undef Expose +#undef Below +#undef GrabSuccess +#undef GrabAlreadyGrabbed +#undef GrabInvalidTime +#undef GrabNotViewable +#undef GrabFrozen +#undef OwnerChangeNewOwner +#undef OwnerChangeDestroy +#undef OwnerChangeClose +#undef NULL + +#if !WEBKIT_CHECK_VERSION(2,4,0) +#define webkit_dom_event_target_add_event_listener_with_closure webkit_dom_event_target_add_event_listener_closure +#define webkit_dom_event_target_remove_event_listener_with_closure webkit_dom_event_target_remove_event_listener_closure +#endif + diff --git a/marshal.list b/marshal.list --- a/marshal.list +++ b/marshal.list @@ -14,8 +14,8 @@ # FLAGS for flag enumeration types (guint) # FLOAT for single-precision float types (gfloat) # DOUBLE for double-precision float types (gdouble) -# STRING for string types (gchar*) -# MSTRING for string types (gchar*) that could be NUL +# GLIBSTRING for string types (gchar*) +# MGLIBSTRING for string types (gchar*) that could be NUL # BOXED for boxed (anonymous but reference counted) types (GBoxed*) # POINTER for anonymous pointer types (gpointer) # NONE deprecated alias for VOID @@ -45,23 +45,24 @@ VOID:POINTER,POINTER BOOLEAN:TOBJECT -BOOLEAN:TOBJECT,STRING,BOXED +BOOLEAN:TOBJECT,GLIBSTRING,BOXED POINTER:TOBJECT -BOOLEAN:INT,INT,STRING -BOOLEAN:STRING,STRING,INT,STRING -BOOLEAN:TOBJECT,STRING -BOOLEAN:TOBJECT,STRING,STRING +BOOLEAN:INT,INT,GLIBSTRING +BOOLEAN:GLIBSTRING,GLIBSTRING,INT,GLIBSTRING +BOOLEAN:TOBJECT,GLIBSTRING +BOOLEAN:TOBJECT,GLIBSTRING,GLIBSTRING +BOOLEAN:TOBJECT,TOBJECT BOOLEAN:TOBJECT,TOBJECT,TOBJECT,TOBJECT -BOOLEAN:TOBJECT,TOBJECT,STRING,TOBJECT +BOOLEAN:TOBJECT,TOBJECT,GLIBSTRING,TOBJECT NONE:TOBJECT,TOBJECT,TOBJECT,TOBJECT NONE:TOBJECT,TOBJECT,MTOBJECT,MTOBJECT BOOLEAN:ENUM,INT BOOLEAN:NONE NONE:NONE -NONE:MSTRING,MSTRING -NONE:TOBJECT,STRING +NONE:MGLIBSTRING,MGLIBSTRING +NONE:TOBJECT,GLIBSTRING NONE:TOBJECT,TOBJECT -NONE:STRING,STRING +NONE:GLIBSTRING,GLIBSTRING NONE:TOBJECT NONE:INT -NONE:STRING +NONE:GLIBSTRING diff --git a/webkit.cabal b/webkit.cabal --- a/webkit.cabal +++ b/webkit.cabal @@ -1,15 +1,15 @@ Name: webkit -Version: 0.12.1 +Version: 0.14.2.1 License: LGPL-2.1 License-file: COPYING -Copyright: (c) 2001-2010 The Gtk2Hs Team +Copyright: (c) 2001-2013 The Gtk2Hs Team Author: Cjacker Huang, Andy Stewart, Axel Simon -Maintainer: gtk2hs-users@sourceforge.net +Maintainer: gtk2hs-users@lists.sourceforge.net Build-Type: Custom -Cabal-Version: >= 1.6.0 +Cabal-Version: >= 1.24 Stability: provisional -homepage: http://www.haskell.org/gtk2hs/ -bug-reports: http://hackage.haskell.org/trac/gtk2hs/ +homepage: http://projects.haskell.org/gtk2hs/ +bug-reports: https://github.com/gtk2hs/webkit/issues Synopsis: Binding to the Webkit library. Description: WebKit is a web content engine, derived from KHTML and KJS from KDE, and used primarily in Apple's Safari browser. It is made to be embedded in @@ -19,45 +19,60 @@ supports DOM, XMLHttpRequest, XSLT, CSS, Javascript/ECMAscript and more. Category: Graphics -Tested-With: GHC == 6.12.1 +Tested-With: GHC == 6.10.4, GHC == 6.12.3, GHC == 7.0.4, GHC == 7.2.1, GHC == 7.6.3 Extra-Source-Files: hswebkit.h - Gtk2HsSetup.hs marshal.list - hierarchy.list - -Data-Dir: demo -Data-Files: Webkit.hs + hierarchy.list + cbits/events.h + cbits/hsgclosure.h + +Data-Dir: demo +Data-Files: Webkit.hs Makefile - + x-Types-File: Graphics/UI/Gtk/WebKit/Types.chs -x-Types-Tag: webkit +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 Source-Repository head - type: darcs - location: http://code.haskell.org/webkit/ + type: git + location: https://github.com/gtk2hs/webkit +custom-setup + setup-depends: base >= 4.6, + Cabal >= 1.24 && < 1.25, + gtk2hs-buildtools >= 0.13.1.0 && < 0.14 + Library - build-depends: base >= 4 && < 5, array, containers, haskell98, mtl, - glib >= 0.12 && < 0.13, - pango >= 0.12 && < 0.13, - cairo >= 0.12 && < 0.13, - gtk >= 0.12 && < 0.13 - - build-tools: gtk2hsC2hs, gtk2hsHookGenerator, gtk2hsTypeGen - + build-depends: base >= 4 && < 5, + bytestring >= 0.9.2 && < 0.11, + glib >= 0.13.1.0 && < 0.14, + pango >= 0.13.0.0 && < 0.14, + cairo >= 0.13.0.0 && < 0.14, + gtk >= 0.13.0.0 && < 0.15, + text >= 1.0.0.0 && < 1.3, + mtl, + transformers + + build-tools: gtk2hsC2hs >= 0.13.11, + gtk2hsHookGenerator, gtk2hsTypeGen + c-sources: Graphics/UI/Gtk/WebKit/DOM/hsevents.c + include-dirs: cbits + exposed-modules: 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 Graphics.UI.Gtk.WebKit.SecurityOrigin Graphics.UI.Gtk.WebKit.SoupAuthDialog + Graphics.UI.Gtk.WebKit.Types Graphics.UI.Gtk.WebKit.WebBackForwardList Graphics.UI.Gtk.WebKit.WebDatabase Graphics.UI.Gtk.WebKit.WebDataSource @@ -70,17 +85,164 @@ 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.CSS + Graphics.UI.Gtk.WebKit.DOM.CSSRule + Graphics.UI.Gtk.WebKit.DOM.CSSRuleList + Graphics.UI.Gtk.WebKit.DOM.CSSStyleDeclaration + Graphics.UI.Gtk.WebKit.DOM.CSSStyleSheet + Graphics.UI.Gtk.WebKit.DOM.CSSValue + Graphics.UI.Gtk.WebKit.DOM.Document + Graphics.UI.Gtk.WebKit.DOM.DocumentType + Graphics.UI.Gtk.WebKit.DOM.DOMImplementation + Graphics.UI.Gtk.WebKit.DOM.DOMNamedFlowCollection + Graphics.UI.Gtk.WebKit.DOM.DOMSettableTokenList + Graphics.UI.Gtk.WebKit.DOM.DOMTokenList + 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.EventTarget + Graphics.UI.Gtk.WebKit.DOM.EventTargetClosures + Graphics.UI.Gtk.WebKit.DOM.File + Graphics.UI.Gtk.WebKit.DOM.FileList + Graphics.UI.Gtk.WebKit.DOM.History + Graphics.UI.Gtk.WebKit.DOM.HTMLAnchorElement + Graphics.UI.Gtk.WebKit.DOM.HTMLAppletElement + Graphics.UI.Gtk.WebKit.DOM.HTMLAreaElement + Graphics.UI.Gtk.WebKit.DOM.HTMLBaseElement + Graphics.UI.Gtk.WebKit.DOM.HTMLBaseFontElement + Graphics.UI.Gtk.WebKit.DOM.HTMLBodyElement + Graphics.UI.Gtk.WebKit.DOM.HTMLBRElement + Graphics.UI.Gtk.WebKit.DOM.HTMLButtonElement + Graphics.UI.Gtk.WebKit.DOM.HTMLCollection + Graphics.UI.Gtk.WebKit.DOM.HTMLDirectoryElement + Graphics.UI.Gtk.WebKit.DOM.HTMLDivElement + Graphics.UI.Gtk.WebKit.DOM.HTMLDListElement + Graphics.UI.Gtk.WebKit.DOM.HTMLDocument + Graphics.UI.Gtk.WebKit.DOM.HTMLElement + Graphics.UI.Gtk.WebKit.DOM.HTMLFieldSetElement + Graphics.UI.Gtk.WebKit.DOM.HTMLFontElement + Graphics.UI.Gtk.WebKit.DOM.HTMLFormElement + Graphics.UI.Gtk.WebKit.DOM.HTMLFrameElement + Graphics.UI.Gtk.WebKit.DOM.HTMLFrameSetElement + Graphics.UI.Gtk.WebKit.DOM.HTMLHeadElement + Graphics.UI.Gtk.WebKit.DOM.HTMLHeadingElement + Graphics.UI.Gtk.WebKit.DOM.HTMLHRElement + Graphics.UI.Gtk.WebKit.DOM.HTMLHtmlElement + Graphics.UI.Gtk.WebKit.DOM.HTMLIFrameElement + Graphics.UI.Gtk.WebKit.DOM.HTMLImageElement + Graphics.UI.Gtk.WebKit.DOM.HTMLInputElement + Graphics.UI.Gtk.WebKit.DOM.HTMLLabelElement + Graphics.UI.Gtk.WebKit.DOM.HTMLLegendElement + Graphics.UI.Gtk.WebKit.DOM.HTMLLIElement + Graphics.UI.Gtk.WebKit.DOM.HTMLLinkElement + Graphics.UI.Gtk.WebKit.DOM.HTMLMapElement + Graphics.UI.Gtk.WebKit.DOM.HTMLMenuElement + Graphics.UI.Gtk.WebKit.DOM.HTMLMetaElement + Graphics.UI.Gtk.WebKit.DOM.HTMLModElement + Graphics.UI.Gtk.WebKit.DOM.HTMLObjectElement + Graphics.UI.Gtk.WebKit.DOM.HTMLOListElement + Graphics.UI.Gtk.WebKit.DOM.HTMLOptGroupElement + Graphics.UI.Gtk.WebKit.DOM.HTMLOptionElement + Graphics.UI.Gtk.WebKit.DOM.HTMLOptionsCollection + Graphics.UI.Gtk.WebKit.DOM.HTMLParagraphElement + Graphics.UI.Gtk.WebKit.DOM.HTMLParamElement + Graphics.UI.Gtk.WebKit.DOM.HTMLPreElement + Graphics.UI.Gtk.WebKit.DOM.HTMLQuoteElement + Graphics.UI.Gtk.WebKit.DOM.HTMLScriptElement + Graphics.UI.Gtk.WebKit.DOM.HTMLSelectElement + Graphics.UI.Gtk.WebKit.DOM.HTMLStyleElement + Graphics.UI.Gtk.WebKit.DOM.HTMLTableCaptionElement + Graphics.UI.Gtk.WebKit.DOM.HTMLTableCellElement + Graphics.UI.Gtk.WebKit.DOM.HTMLTableColElement + Graphics.UI.Gtk.WebKit.DOM.HTMLTableElement + Graphics.UI.Gtk.WebKit.DOM.HTMLTableRowElement + Graphics.UI.Gtk.WebKit.DOM.HTMLTableSectionElement + Graphics.UI.Gtk.WebKit.DOM.HTMLTextAreaElement + Graphics.UI.Gtk.WebKit.DOM.HTMLTitleElement + Graphics.UI.Gtk.WebKit.DOM.HTMLUListElement + Graphics.UI.Gtk.WebKit.DOM.KeyboardEvent + 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 + Graphics.UI.Gtk.WebKit.DOM.Node + 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.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.Storage + Graphics.UI.Gtk.WebKit.DOM.Text + 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.DOMStringList + Graphics.UI.Gtk.WebKit.DOM.Geolocation + Graphics.UI.Gtk.WebKit.DOM.HTMLCanvasElement + Graphics.UI.Gtk.WebKit.DOM.HTMLDetailsElement + Graphics.UI.Gtk.WebKit.DOM.HTMLEmbedElement + Graphics.UI.Gtk.WebKit.DOM.HTMLKeygenElement + Graphics.UI.Gtk.WebKit.DOM.HTMLMarqueeElement + Graphics.UI.Gtk.WebKit.DOM.HTMLMediaElement + Graphics.UI.Gtk.WebKit.DOM.HTMLVideoElement + Graphics.UI.Gtk.WebKit.DOM.MediaError + Graphics.UI.Gtk.WebKit.DOM.StorageInfo + Graphics.UI.Gtk.WebKit.DOM.TimeRanges + -- Graphics.UI.Gtk.WebKit.DOM.WebKitAnimation + -- Graphics.UI.Gtk.WebKit.DOM.WebKitAnimationList + other-modules: Graphics.UI.Gtk.WebKit.Internal - Graphics.UI.Gtk.WebKit.Types Graphics.UI.Gtk.WebKit.Signals - extensions: ForeignFunctionInterface - + default-language: Haskell98 + default-extensions: ForeignFunctionInterface, PatternSynonyms, DeriveDataTypeable + include-dirs: . + cpp-options: -DDISABLE_DEPRECATED -U__BLOCKS__ -D__attribute__(A)= -D_Nullable= -D_Nonnull= + x-Signals-File: Graphics/UI/Gtk/WebKit/Signals.chs x-Signals-Modname: Graphics.UI.Gtk.WebKit.Signals x-Signals-Types: marshal.list x-Signals-Import: Graphics.UI.GtkInternals - - x-c2hs-Header: hswebkit.h - pkgconfig-depends: webkit-1.0 >= 1.1.15 + + hs-source-dirs: . + pkgconfig-depends: webkit-1.0 >= 1.8 + x-c2hs-Header: hswebkit.h